SGI Freeware 1999 August/SGI Freeware 1999 August.iso/dist/fw_bash.idb/usr/freeware/catman/u_man/cat1/bash.Z/bash

Text File | 1999-04-16 | 304.8 KB | 5,677 lines

     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



     NNNNAAAAMMMMEEEE
      bash - GNU Bourne-Again SHell

     SSSSYYYYNNNNOOOOPPPPSSSSIIIISSSS
      bbbbaaaasssshhhh [options] [file]

     CCCCOOOOPPPPYYYYRRRRIIIIGGGGHHHHTTTT
      Bash is Copyright (C)    1989-1999 by the Free Software
      Foundation, Inc.

     DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
      BBBBaaaasssshhhh is an sssshhhh-compatible command language interpreter    that
      executes commands read from the standard input or from a
      file.     BBBBaaaasssshhhh also incorporates    useful features    from the _K_o_r_n
      and _C    shells (kkkksssshhhh and    ccccsssshhhh).

      BBBBaaaasssshhhh is intended to be a conformant implementation of    the
      IEEE POSIX Shell and Tools specification (IEEE Working Group
      1003.2).

     OOOOPPPPTTTTIIIIOOOONNNNSSSS
      In addition to the single-character shell options documented
      in the description of    the sssseeeetttt    builtin    command, bbbbaaaasssshhhh
      interprets the following options when    it is invoked:

      ----cccc _s_t_r_i_n_g If the ----cccc option is    present, then commands are
            read from _s_t_r_i_n_g.  If there    are arguments after
            the    _s_t_r_i_n_g,    they are assigned to the positional
            parameters,    starting with $$$$0000.
      ----rrrr        If the ----rrrr option is    present, the shell becomes
            _r_e_s_t_r_i_c_t_e_d (see RRRREEEESSSSTTTTRRRRIIIICCCCTTTTEEEEDDDD SSSSHHHHEEEELLLLLLLL below).
      ----iiii        If the ----iiii option is    present, the shell is
            _i_n_t_e_r_a_c_t_i_v_e.
      ----ssss        If the ----ssss option is    present, or if no arguments
            remain after option    processing, then commands are
            read from the standard input.  This    option allows
            the    positional parameters to be set    when invoking
            an interactive shell.
      ----DDDD        A list of all double-quoted    strings    preceded by $$$$
            is printed on the standard ouput.  These are the
            strings that are subject to    language translation
            when the current locale is not C or    POSIX.    This
            implies the    ----nnnn option; no commands will be
            executed.
      --------        A -------- signals the end of options and    disables
            further option processing.    Any arguments after
            the    -------- are treated as filenames and    arguments.  An
            argument of    ---- is equivalent    to --------.

      BBBBaaaasssshhhh also interprets a number    of multi-character options.
      These    options    must appear on the command line    before the
      single-character options in order for    them to    be recognized.



     Page 1                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      --------dddduuuummmmpppp----ppppoooo----ssssttttrrrriiiinnnnggggssss
           Equivalent to ----DDDD, but the output    is in the GNU _g_e_t_t_e_x_t
           ppppoooo (portable object) file format.
      --------dddduuuummmmpppp----ssssttttrrrriiiinnnnggggssss
           Equivalent to ----DDDD.
      --------hhhheeeellllpppp
           Display a usage message on standard output and exit
           successfully.
      --------llllooooggggiiiinnnn
           Make bbbbaaaasssshhhh act as    if it had been invoked as a login
           shell (see IIIINNNNVVVVOOOOCCCCAAAATTTTIIIIOOOONNNN below).
      --------nnnnooooeeeeddddiiiittttiiiinnnngggg
           Do not use the GNU rrrreeeeaaaaddddlllliiiinnnneeee library to read command
           lines if    interactive.
      --------nnnnoooopppprrrrooooffffiiiilllleeee
           Do not read either the system-wide startup file
           /_e_t_c/_p_r_o_f_i_l_e or any of the personal initialization
           files ~/._b_a_s_h__p_r_o_f_i_l_e, ~/._b_a_s_h__l_o_g_i_n, or    ~/._p_r_o_f_i_l_e.
           By default, bbbbaaaasssshhhh    reads these files when it is invoked
           as a login shell    (see IIIINNNNVVVVOOOOCCCCAAAATTTTIIIIOOOONNNN    below).
      --------nnnnoooorrrrcccc
           Do not read and execute the personal initialization
           file ~/._b_a_s_h_r_c if the shell is interactive.  This
           option is on by default if the shell is invoked as sssshhhh.
      --------ppppoooossssiiiixxxx
           Change the behavior of bbbbaaaasssshhhh where the default operation
           differs from the    POSIX 1003.2 standard to match the
           standard.
      --------rrrrccccffffiiiilllleeee _f_i_l_e
           Execute commands    from _f_i_l_e instead of the standard
           personal    initialization file ~/._b_a_s_h_r_c if the shell is
           interactive (see    IIIINNNNVVVVOOOOCCCCAAAATTTTIIIIOOOONNNN below).
      --------rrrreeeessssttttrrrriiiicccctttteeeedddd
           The shell becomes restricted (see RRRREEEESSSSTTTTRRRRIIIICCCCTTTTEEEEDDDD SSSSHHHHEEEELLLLLLLL
           below).
      --------vvvveeeerrrrbbbboooosssseeee
           Equivalent to  ----vvvv.
      --------vvvveeeerrrrssssiiiioooonnnn
           Show version information    for this instance of bbbbaaaasssshhhh on
           the standard output and exit successfully.

     AAAARRRRGGGGUUUUMMMMEEEENNNNTTTTSSSS
      If arguments remain after option processing, and neither the
      ----cccc nor the ----ssss    option has been    supplied, the first argument
      is assumed to    be the name of a file containing shell
      commands.  If    bbbbaaaasssshhhh is    invoked    in this    fashion, $$$$0000 is set to
      the name of the file,    and the    positional parameters are set
      to the remaining arguments.  BBBBaaaasssshhhh reads and executes
      commands from    this file, then    exits.    BBBBaaaasssshhhh's exit status is
      the exit status of the last command executed in the script.
      If no    commands are executed, the exit    status is 0.




     Page 2                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



     IIIINNNNVVVVOOOOCCCCAAAATTTTIIIIOOOONNNN
      A _l_o_g_i_n _s_h_e_l_l    is one whose first character of    argument zero
      is a ----, or one started with the --------llllooooggggiiiinnnn option.

      An _i_n_t_e_r_a_c_t_i_v_e shell is one whose standard input and output
      are both connected to    terminals (as determined by
      _i_s_a_t_t_y(3)), or one started with the ----iiii option.  PPPPSSSS1111 is set
      and $$$$---- includes iiii if bbbbaaaasssshhhh is interactive, allowing a shell
      script or a startup file to test this    state.

      The following    paragraphs describe how    bbbbaaaasssshhhh executes its
      startup files.  If any of the    files exist but    cannot be
      read,    bbbbaaaasssshhhh reports an    error.    Tildes are expanded in file
      names    as described below under TTTTiiiillllddddeeee EEEExxxxppppaaaannnnssssiiiioooonnnn in the
      EEEEXXXXPPPPAAAANNNNSSSSIIIIOOOONNNN section.

      When bbbbaaaasssshhhh is invoked as an interactive login shell, or as a
      non-interactive shell    with the --------llllooooggggiiiinnnn option, it first
      reads    and executes commands from the file /_e_t_c/_p_r_o_f_i_l_e, if
      that file exists.  After reading that    file, it looks for
      ~/._b_a_s_h__p_r_o_f_i_l_e, ~/._b_a_s_h__l_o_g_i_n, and ~/._p_r_o_f_i_l_e, in that
      order, and reads and executes    commands from the first    one
      that exists and is readable.    The --------nnnnoooopppprrrrooooffffiiiilllleeee    option may be
      used when the    shell is started to inhibit this behavior.

      When a login shell exits, bbbbaaaasssshhhh reads and executes commands
      from the file    ~/._b_a_s_h__l_o_g_o_u_t,    if it exists.

      When an interactive shell that is not    a login    shell is
      started, bbbbaaaasssshhhh    reads and executes commands from ~/._b_a_s_h_r_c, if
      that file exists.  This may be inhibited by using the    --------nnnnoooorrrrcccc
      option.  The --------rrrrccccffffiiiilllleeee    _f_i_l_e option will force bbbbaaaasssshhhh to read
      and execute commands from _f_i_l_e instead of ~/._b_a_s_h_r_c.

      When bbbbaaaasssshhhh is started non-interactively, to run a shell
      script, for example, it looks    for the    variable BBBBAAAASSSSHHHH____EEEENNNNVVVV in
      the environment, expands its value if    it appears there, and
      uses the expanded value as the name of a file    to read    and
      execute.  BBBBaaaasssshhhh behaves as if the following command were
      executed:

           if [ -n "$BASH_ENV" ]; then . "$BASH_ENV"; fi
      but the value    of the PPPPAAAATTTTHHHH variable is    not used to search for
      the file name.

      If bbbbaaaasssshhhh is invoked with the name sssshhhh, it tries    to mimic the
      startup behavior of historical versions of sssshhhh    as closely as
      possible, while conforming to    the POSIX standard as well.
      When invoked as an interactive login shell, or a non-
      interactive shell with the --------llllooooggggiiiinnnn option, it    first attempts
      to read and execute commands from /_e_t_c/_p_r_o_f_i_l_e and
      ~/._p_r_o_f_i_l_e, in that order.  The --------nnnnoooopppprrrrooooffffiiiilllleeee option may be



     Page 3                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      used to inhibit this behavior.  When invoked as an
      interactive shell with the name sssshhhh, bbbbaaaasssshhhh looks for the
      variable EEEENNNNVVVV,    expands    its value if it    is defined, and    uses
      the expanded value as    the name of a file to read and
      execute.  Since a shell invoked as sssshhhh    does not attempt to
      read and execute commands from any other startup files, the
      --------rrrrccccffffiiiilllleeee option has no effect.  A non-interactive shell
      invoked with the name    sssshhhh does    not attempt to read any    other
      startup files. When invoked as sssshhhh, bbbbaaaasssshhhh enters _p_o_s_i_x mode
      after    the startup files are read.

      When bbbbaaaasssshhhh is started in _p_o_s_i_x    mode, as with the --------ppppoooossssiiiixxxx
      command line option, it follows the POSIX standard for
      startup files.  In this mode,    interactive shells expand the
      EEEENNNNVVVV variable and commands are    read and executed from the
      file whose name is the expanded value.  No other startup
      files    are read.

      BBBBaaaasssshhhh attempts    to determine when it is    being run by the
      remote shell daemon, usually _r_s_h_d.  If bbbbaaaasssshhhh determines it is
      being    run by _r_s_h_d, it    reads and executes commands from
      ~/._b_a_s_h_r_c, if    that file exists and is    readable.  It will not
      do this if invoked as    sssshhhh.  The --------nnnnoooorrrrcccc    option may be used to
      inhibit this behavior, and the --------rrrrccccffffiiiilllleeee option may be    used
      to force another file    to be read, but    _r_s_h_d does not
      generally invoke the shell with those    options    or allow them
      to be    specified.

      If the shell is started with the effective user (group) id
      not equal to the real    user (group) id, and the ----pppp option is
      not supplied,    no startup files are read, shell functions are
      not inherited    from the environment, the SSSSHHHHEEEELLLLLLLLOOOOPPPPTTTTSSSS variable,
      if it    appears    in the environment, is ignored,    and the
      effective user id is set to the real user id.     If the    ----pppp
      option is supplied at    invocation, the    startup    behavior is
      the same, but    the effective user id is not reset.

     DDDDEEEEFFFFIIIINNNNIIIITTTTIIIIOOOONNNNSSSS
      The following    definitions are    used throughout    the rest of
      this document.
      bbbbllllaaaannnnkkkk
           A space or tab.
      wwwwoooorrrrdddd A sequence of characters    considered as a    single unit by
           the shell.  Also    known as a ttttooookkkkeeeennnn.
      nnnnaaaammmmeeee A _w_o_r_d consisting only of alphanumeric characters and
           underscores, and    beginning with an alphabetic character
           or an underscore.  Also referred    to as an iiiiddddeeeennnnttttiiiiffffiiiieeeerrrr.
      mmmmeeeettttaaaacccchhhhaaaarrrraaaacccctttteeeerrrr
           A character that, when unquoted,    separates words.  One
           of the following:
           ||||  &&&& ;;;; ((((    )))) <<<< >>>> ssssppppaaaacccceeee ttttaaaabbbb
      ccccoooonnnnttttrrrroooollll ooooppppeeeerrrraaaattttoooorrrr



     Page 4                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           A _t_o_k_e_n that performs a control function.  It is    one of
           the following symbols:
           |||||||| &&&& &&&&&&&& ;;;; ;;;;;;;; (((( ))))    |||| <<<<nnnneeeewwwwlllliiiinnnneeee>>>>

     RRRREEEESSSSEEEERRRRVVVVEEEEDDDD WWWWOOOORRRRDDDDSSSS
      _R_e_s_e_r_v_e_d _w_o_r_d_s are words that    have a special meaning to the
      shell.  The following    words are recognized as    reserved when
      unquoted and either the first    word of    a simple command (see
      SSSSHHHHEEEELLLLLLLL    GGGGRRRRAAAAMMMMMMMMAAAARRRR    below) or the third word of a ccccaaaasssseeee or ffffoooorrrr
      command:

      !!!! ccccaaaasssseeee  ddddoooo ddddoooonnnneeee eeeelllliiiiffff eeeellllsssseeee eeeessssaaaacccc ffffiiii ffffoooorrrr    ffffuuuunnnnccccttttiiiioooonnnn iiiiffff iiiinnnn sssseeeelllleeeecccctttt
      tttthhhheeeennnn uuuunnnnttttiiiillll wwwwhhhhiiiilllleeee {{{{ }}}} ttttiiiimmmmeeee [[[[[[[[ ]]]]]]]]

     SSSSHHHHEEEELLLLLLLL GGGGRRRRAAAAMMMMMMMMAAAARRRR
    SSSSiiiimmmmpppplllleeee CCCCoooommmmmmmmaaaannnnddddssss
      A _s_i_m_p_l_e _c_o_m_m_a_n_d is a    sequence of optional variable
      assignments followed by bbbbllllaaaannnnkkkk-separated words    and
      redirections,    and terminated by a _c_o_n_t_r_o_l _o_p_e_r_a_t_o_r.  The
      first    word specifies the command to be executed.  The
      remaining words are passed as    arguments to the invoked
      command.

      The return value of a    _s_i_m_p_l_e _c_o_m_m_a_n_d is its exit status, or
      128+_n    if the command is terminated by    signal _n.

    PPPPiiiippppeeeelllliiiinnnneeeessss
      A _p_i_p_e_l_i_n_e is    a sequence of one or more commands separated
      by the character ||||.  The format for a    pipeline is:

           [ttttiiiimmmmeeee [----pppp]] [ ! ] _c_o_m_m_a_n_d [ |||| _c_o_m_m_a_n_d_2 ... ]

      The standard output of _c_o_m_m_a_n_d is connected to the standard
      input    of _c_o_m_m_a_n_d_2.  This connection is performed before any
      redirections specified by the    command    (see RRRREEEEDDDDIIIIRRRREEEECCCCTTTTIIIIOOOONNNN
      below).

      If the reserved word !!!! precedes a pipeline, the exit status
      of that pipeline is the logical NOT of the exit status of
      the last command.  Otherwise,    the status of the pipeline is
      the exit status of the last command.    The shell waits    for
      all commands in the pipeline to terminate before returning a
      value.

      If the ttttiiiimmmmeeee reserved word precedes a pipeline, the elapsed
      as well as user and system time consumed by its execution
      are reported when the    pipeline terminates.  The ----pppp option
      changes the output format to that specified by POSIX.     The
      TTTTIIIIMMMMEEEEFFFFOOOORRRRMMMMAAAATTTT variable may be set to a format string that
      specifies how    the timing information should be displayed;
      see the description of TTTTIIIIMMMMEEEEFFFFOOOORRRRMMMMAAAATTTT under SSSShhhheeeellllllll    VVVVaaaarrrriiiiaaaabbbblllleeeessss
      below.



     Page 5                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      Each command in a pipeline is    executed as a separate process
      (i.e., in a subshell).

    LLLLiiiissssttttssss
      A _l_i_s_t is a sequence of one or more pipelines    separated by
      one of the operators ;;;;, &&&&, &&&&&&&&, or ||||||||,    and optionally
      terminated by    one of ;;;;, &&&&, or    <<<<nnnneeeewwwwlllliiiinnnneeee>>>>.

      Of these list    operators, &&&&&&&& and |||||||| have equal    precedence,
      followed by ;;;;    and &&&&,,,, which have equal    precedence.

      If a command is terminated by    the control operator &&&&,    the
      shell    executes the command in    the _b_a_c_k_g_r_o_u_n_d in a subshell.
      The shell does not wait for the command to finish, and the
      return status    is 0.  Commands    separated by a ;;;; are executed
      sequentially;    the shell waits    for each command to terminate
      in turn.  The    return status is the exit status of the    last
      command executed.

      The control operators    &&&&&&&& and |||||||| denote AND lists and OR
      lists, respectively.    An AND list has    the form

           _c_o_m_m_a_n_d &&&&&&&& _c_o_m_m_a_n_d_2

      _c_o_m_m_a_n_d_2 is executed if, and only if,    _c_o_m_m_a_n_d    returns    an
      exit status of zero.

      An OR    list has the form

           _c_o_m_m_a_n_d |||||||| _c_o_m_m_a_n_d_2

      _c_o_m_m_a_n_d_2 is executed if and only if _c_o_m_m_a_n_d returns a    non-
      zero exit status.  The return    status of AND and OR lists is
      the exit status of the last command executed in the list.

    CCCCoooommmmppppoooouuuunnnndddd CCCCoooommmmmmmmaaaannnnddddssss
      A _c_o_m_p_o_u_n_d _c_o_m_m_a_n_d is    one of the following:

      (_l_i_s_t)
           _l_i_s_t is executed    in a subshell.    Variable assignments
           and builtin commands that affect    the shell's
           environment do not remain in effect after the command
           completes.  The return status is    the exit status    of
           _l_i_s_t.

      { _l_i_s_t; }
           _l_i_s_t is simply executed in the current shell
           environment.  _l_i_s_t must be terminated with a newline or
           semicolon.  This    is known as a _g_r_o_u_p _c_o_m_m_a_n_d.  The
           return status is    the exit status    of _l_i_s_t.

      ((_e_x_p_r_e_s_s_i_o_n))



     Page 6                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           The _e_x_p_r_e_s_s_i_o_n is evaluated according to    the rules
           described below under AAAARRRRIIIITTTTHHHHMMMMEEEETTTTIIIICCCC    EEEEVVVVAAAALLLLUUUUAAAATTTTIIIIOOOONNNN.  If    the
           value of    the expression is non-zero, the    return status
           is 0; otherwise the return status is 1.    This is
           exactly equivalent to lllleeeetttt """"_e_x_p_r_e_s_s_i_o_n"""".

      [[[[[[[[ _e_x_p_r_e_s_s_i_o_n    ]]]]]]]]
           Return a    status of 0 or 1 depending on the evaluation
           of the conditional expression _e_x_p_r_e_s_s_i_o_n.  Expressions
           are composed of the primaries described below under
           CCCCOOOONNNNDDDDIIIITTTTIIIIOOOONNNNAAAALLLL EEEEXXXXPPPPRRRREEEESSSSSSSSIIIIOOOONNNNSSSS.     Word splitting    and pathname
           expansion are not performed on the words    between    the [[[[[[[[
           and ]]]]]]]]; tilde expansion,    parameter and variable
           expansion, arithmetic expansion,    command    substitution,
           process substitution, and quote removal are performed.

           When the    ======== and !!!!==== operators are    used, the string to
           the right of the    operator is considered a pattern and
           matched according to the    rules described    below under
           PPPPaaaatttttttteeeerrrrnnnn MMMMaaaattttcccchhhhiiiinnnngggg.  The return value is 0    if the string
           matches or does not match the pattern, respectively,
           and 1 otherwise.     Any part of the pattern may be    quoted
           to force    it to be matched as a string.

           Expressions may be combined using the following
           operators, listed in decreasing order of    precedence:

           (((( _e_x_p_r_e_s_s_i_o_n ))))
            Returns the    value of _e_x_p_r_e_s_s_i_o_n.  This may be used
            to override    the normal precedence of operators.
           !!!! _e_x_p_r_e_s_s_i_o_n
            True if _e_x_p_r_e_s_s_i_o_n is false.
           _e_x_p_r_e_s_s_i_o_n_1 &&&&&&&& _e_x_p_r_e_s_s_i_o_n_2
            True if both _e_x_p_r_e_s_s_i_o_n_1 and _e_x_p_r_e_s_s_i_o_n_2 are true.
           _e_x_p_r_e_s_s_i_o_n_1 |||||||| _e_x_p_r_e_s_s_i_o_n_2
            True if either _e_x_p_r_e_s_s_i_o_n_1 or _e_x_p_r_e_s_s_i_o_n_2 is true.

      The &&&&&&&& and ||||||||    operators do not execute _e_x_p_r_e_s_s_i_o_n_2 if    the
      value    of _e_x_p_r_e_s_s_i_o_n_1 is sufficient to    determine the return
      value    of the entire conditional expression.

      ffffoooorrrr _n_a_m_e [ iiiinnnn    _w_o_r_d ] ; ddddoooo _l_i_s_t ; ddddoooonnnneeee
           The list    of words following iiiinnnn is expanded, generating
           a list of items.     The variable _n_a_m_e is set to each
           element of this list in turn, and _l_i_s_t is executed each
           time.  If the iiiinnnn    _w_o_r_d is    omitted, the ffffoooorrrr command
           executes    _l_i_s_t once for each positional parameter    that
           is set (see PPPPAAAARRRRAAAAMMMMEEEETTTTEEEERRRRSSSS below).  The return status is
           the exit    status of the last command that    executes.  If
           the expansion of    the items following iiiinnnn results in an
           empty list, no commands are executed, and the return
           status is 0.



     Page 7                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      sssseeeelllleeeecccctttt _n_a_m_e [    iiiinnnn _w_o_r_d    ] ; ddddoooo _l_i_s_t ; ddddoooonnnneeee
           The list    of words following iiiinnnn is expanded, generating
           a list of items.     The set of expanded words is printed
           on the standard error, each preceded by a number.  If
           the iiiinnnn _w_o_r_d is omitted, the positional parameters are
           printed (see PPPPAAAARRRRAAAAMMMMEEEETTTTEEEERRRRSSSS below).    The PPPPSSSS3333    prompt is then
           displayed and a line read from the standard input.  If
           the line    consists of a number corresponding to one of
           the displayed words, then the value of _n_a_m_e is set to
           that word.  If the line is empty, the words and prompt
           are displayed again.  If    EOF is read, the command
           completes.  Any other value read    causes _n_a_m_e to be set
           to null.     The line read is saved    in the variable    RRRREEEEPPPPLLLLYYYY.
           The _l_i_s_t    is executed after each selection until a bbbbrrrreeeeaaaakkkk
           or rrrreeeettttuuuurrrrnnnn command is executed.  The exit    status of
           sssseeeelllleeeecccctttt is the exit status of the    last command executed
           in _l_i_s_t,    or zero    if no commands were executed.

      ccccaaaasssseeee _w_o_r_d iiiinnnn [ ( _p_a_t_t_e_r_n [ |||| _p_a_t_t_e_r_n ] ... ) _l_i_s_t ;; ] ... eeeessssaaaacccc
           A ccccaaaasssseeee command first expands _w_o_r_d, and tries to match
           it against each _p_a_t_t_e_r_n in turn,    using the same
           matching    rules as for pathname expansion    (see PPPPaaaatttthhhhnnnnaaaammmmeeee
           EEEExxxxppppaaaannnnssssiiiioooonnnn below).  When a match is found, the
           corresponding _l_i_s_t is executed.    After the first    match,
           no subsequent matches are attempted.  The exit status
           is zero if no pattern matches.  Otherwise, it is    the
           exit status of the last command executed    in _l_i_s_t.

     ffffiiii
      iiiiffff _l_i_s_t; tttthhhheeeennnn    _l_i_s_t; [    eeeelllliiiiffff _l_i_s_t; tttthhhheeeennnn    _l_i_s_t; ]    ... [ eeeellllsssseeee _l_i_s_t; ]
           The iiiiffff _l_i_s_t is executed.     If its    exit status is zero,
           the tttthhhheeeennnn    _l_i_s_t is    executed.  Otherwise, each eeeelllliiiiffff    _l_i_s_t
           is executed in turn, and    if its exit status is zero,
           the corresponding tttthhhheeeennnn _l_i_s_t is executed and the command
           completes.  Otherwise, the eeeellllsssseeee _l_i_s_t is executed, if
           present.     The exit status is the    exit status of the
           last command executed, or zero if no condition tested
           true.

      wwwwhhhhiiiilllleeee    _l_i_s_t; ddddoooo _l_i_s_t; ddddoooonnnneeee
      uuuunnnnttttiiiillll    _l_i_s_t; ddddoooo _l_i_s_t; ddddoooonnnneeee
           The wwwwhhhhiiiilllleeee command continuously executes the ddddoooo _l_i_s_t as
           long as the last    command    in _l_i_s_t    returns    an exit    status
           of zero.     The uuuunnnnttttiiiillll command is identical    to the wwwwhhhhiiiilllleeee
           command,    except that the    test is    negated; the ddddoooo    _l_i_s_t
           is executed as long as the last command in _l_i_s_t returns
           a non-zero exit status.    The exit status    of the wwwwhhhhiiiilllleeee
           and uuuunnnnttttiiiillll commands is the exit status of    the last ddddoooo
           _l_i_s_t command executed, or zero if none was executed.

      [ ffffuuuunnnnccccttttiiiioooonnnn ] _n_a_m_e () { _l_i_s_t; }
           This defines a function named _n_a_m_e.  The    _b_o_d_y of    the



     Page 8                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           function    is the _l_i_s_t of commands    between    { and }.  This
           list is executed    whenever _n_a_m_e is specified as the name
           of a simple command.  The exit status of    a function is
           the exit    status of the last command executed in the
           body.  (See FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNNSSSS below.)

     CCCCOOOOMMMMMMMMEEEENNNNTTTTSSSS
      In a non-interactive shell, or an interactive    shell in which
      the iiiinnnntttteeeerrrraaaaccccttttiiiivvvveeee____ccccoooommmmmmmmeeeennnnttttssss option to the sssshhhhoooopppptttt builtin is
      enabled (see SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below), a    word beginning
      with #### causes    that word and all remaining characters on that
      line to be ignored.  An interactive shell without the
      iiiinnnntttteeeerrrraaaaccccttttiiiivvvveeee____ccccoooommmmmmmmeeeennnnttttssss option enabled does not allow comments.
      The iiiinnnntttteeeerrrraaaaccccttttiiiivvvveeee____ccccoooommmmmmmmeeeennnnttttssss option is on    by default in
      interactive shells.

     QQQQUUUUOOOOTTTTIIIINNNNGGGG
      _Q_u_o_t_i_n_g is used to remove the    special    meaning    of certain
      characters or    words to the shell.  Quoting can be used to
      disable special treatment for    special    characters, to prevent
      reserved words from being recognized as such,    and to prevent
      parameter expansion.

      Each of the _m_e_t_a_c_h_a_r_a_c_t_e_r_s listed above under    DDDDEEEEFFFFIIIINNNNIIIITTTTIIIIOOOONNNNSSSS
      has special meaning to the shell and must be quoted if they
      are to represent themselves.    There are three    quoting
      mechanisms: the _e_s_c_a_p_e _c_h_a_r_a_c_t_e_r, single quotes, and double
      quotes.

      A non-quoted backslash (\\\\) is    the _e_s_c_a_p_e _c_h_a_r_a_c_t_e_r.  It
      preserves the    literal    value of the next character that
      follows, with    the exception of <newline>.  If    a \\\\<newline>
      pair appears,    and the    backslash is not itself    quoted,    the
      \\\\<newline> is    treated    as a line continuation (that is, it is
      removed from the input stream    and effectively    ignored).

      Enclosing characters in single quotes    preserves the literal
      value    of each    character within the quotes.  A    single quote
      may not occur    between    single quotes, even when preceded by a
      backslash.

      Enclosing characters in double quotes    preserves the literal
      value    of all characters within the quotes, with the
      exception of $$$$, ````, and \\\\.  The characters $$$$ and ```` retain
      their    special    meaning    within double quotes.  The backslash
      retains its special meaning only when    followed by one    of the
      following characters:     $$$$, ````, """", \\\\, or    <<<<nnnneeeewwwwlllliiiinnnneeee>>>>.  A double
      quote    may be quoted within double quotes by preceding    it
      with a backslash.

      The special parameters **** and @@@@ have special meaning when in
      double quotes    (see PPPPAAAARRRRAAAAMMMMEEEETTTTEEEERRRRSSSS    below).



     Page 9                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      Words    of the form $$$$'_s_t_r_i_n_g' are treated specially.  The word
      expands to _s_t_r_i_n_g, with backslash-escaped characters
      replaced as specifed by the ANSI C standard.    Backslash
      escape sequences, if present,    are decoded as follows:
           \\\\aaaa   alert (bell)
           \\\\bbbb   backspace
           \\\\eeee   an escape character
           \\\\ffff   form feed
           \\\\nnnn   new    line
           \\\\rrrr   carriage return
           \\\\tttt   horizontal tab
           \\\\vvvv   vertical tab
           \\\\\\\\   backslash
           \\\\_n_n_n the    character whose    ASCII code is the octal    value
            _n_n_n    (one to    three digits)
           \\\\xxxx_n_n_n
            the    character whose    ASCII code is the hexadecimal
            value _n_n_n (one to three digits)

      The translated result    is single-quoted, as if    the dollar
      sign had not been present.

      A double-quoted string preceded by a dollar sign ($$$$) will
      cause    the string to be translated according to the current
      locale.  If the current locale is CCCC or PPPPOOOOSSSSIIIIXXXX,    the dollar
      sign is ignored.  If the string is translated    and replaced,
      the replacement is double-quoted.

     PPPPAAAARRRRAAAAMMMMEEEETTTTEEEERRRRSSSS
      A _p_a_r_a_m_e_t_e_r is an entity that    stores values.    It can be a
      _n_a_m_e,    a number, or one of the    special    characters listed
      below    under SSSSppppeeeecccciiiiaaaallll PPPPaaaarrrraaaammmmeeeetttteeeerrrrssss.  For the shell's purposes, a
      _v_a_r_i_a_b_l_e is a    parameter denoted by a _n_a_m_e.

      A parameter is set if    it has been assigned a value.  The
      null string is a valid value.     Once a    variable is set, it
      may be unset only by using the uuuunnnnsssseeeetttt builtin command (see
      SSSSHHHHEEEELLLLLLLL    BBBBUUUUIIIILLLLTTTTIIIINNNN    CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below).

      A _v_a_r_i_a_b_l_e may be assigned to    by a statement of the form

           _n_a_m_e=[_v_a_l_u_e]

      If _v_a_l_u_e is not given, the variable is assigned the null
      string.  All _v_a_l_u_e_s undergo tilde expansion, parameter and
      variable expansion, string expansion,    command    substitution,
      arithmetic expansion,    and quote removal (see EEEEXXXXPPPPAAAANNNNSSSSIIIIOOOONNNN
      below).  If the variable has its iiiinnnntttteeeeggggeeeerrrr attribute set (see
      ddddeeeeccccllllaaaarrrreeee below    in SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS) then    _v_a_l_u_e is
      subject to arithmetic    expansion even if the $((...))
      expansion is not used    (see AAAArrrriiiitttthhhhmmmmeeeettttiiiicccc    EEEExxxxppppaaaannnnssssiiiioooonnnn below).
      Word splitting is not    performed, with    the exception of """"$$$$@@@@""""



     Page 10                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      as explained below under SSSSppppeeeecccciiiiaaaallll PPPPaaaarrrraaaammmmeeeetttteeeerrrrssss.    Pathname
      expansion is not performed.

    PPPPoooossssiiiittttiiiioooonnnnaaaallll PPPPaaaarrrraaaammmmeeeetttteeeerrrrssss
      A _p_o_s_i_t_i_o_n_a_l _p_a_r_a_m_e_t_e_r is a parameter    denoted    by one or more
      digits, other    than the single    digit 0.  Positional
      parameters are assigned from the shell's arguments when it
      is invoked, and may be reassigned using the sssseeeetttt builtin
      command.  Positional parameters may not be assigned to with
      assignment statements.  The positional parameters are
      temporarily replaced when a shell function is    executed (see
      FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNNSSSS below).

      When a positional parameter consisting of more than a    single
      digit    is expanded, it    must be    enclosed in braces (see
      EEEEXXXXPPPPAAAANNNNSSSSIIIIOOOONNNN below).

    SSSSppppeeeecccciiiiaaaallll    PPPPaaaarrrraaaammmmeeeetttteeeerrrrssss
      The shell treats several parameters specially.  These
      parameters may only be referenced; assignment    to them    is not
      allowed.
      ****    Expands to the positional parameters, starting from
           one.  When the expansion    occurs within double quotes,
           it expands to a single word with    the value of each
           parameter separated by the first    character of the IIIIFFFFSSSS
           special variable.  That is, "$$$$****"    is equivalent to
           "$$$$1111_c$$$$2222_c............", where _c is the first character of the
           value of    the IIIIFFFFSSSS    variable.  If IIIIFFFFSSSS is unset, the
           parameters are separated    by spaces.  If IIIIFFFFSSSS is null,
           the parameters are joined without intervening
           separators.
      @@@@    Expands to the positional parameters, starting from
           one.  When the expansion    occurs within double quotes,
           each parameter expands to a separate word.  That    is,
           "$$$$@@@@" is equivalent to "$$$$1111" "$$$$2222" ...  When there are no
           positional parameters, "$$$$@@@@" and $$$$@@@@ expand to nothing
           (i.e., they are removed).
      ####    Expands to the number of    positional parameters in
           decimal.
      ????    Expands to the status of    the most recently executed
           foreground pipeline.
      ----    Expands to the current option flags as specified    upon
           invocation, by the sssseeeetttt builtin command, or those    set by
           the shell itself    (such as the ----iiii    option).
      $$$$    Expands to the process ID of the    shell.    In a ()
           subshell, it expands to the process ID of the current
           shell, not the subshell.
      !!!!    Expands to the process ID of the    most recently executed
           background (asynchronous) command.
      0000    Expands to the name of the shell    or shell script.  This
           is set at shell initialization.    If bbbbaaaasssshhhh    is invoked
           with a file of commands,    $$$$0000 is set to the name of that



     Page 11                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           file.  If bbbbaaaasssshhhh is started with the ----cccc option, then $$$$0000
           is set to the first argument after the string to    be
           executed, if one    is present.  Otherwise,    it is set to
           the file    name used to invoke bbbbaaaasssshhhh, as given by argument
           zero.
      ____    At shell    startup, set to    the absolute file name of the
           shell or    shell script being executed as passed in the
           argument    list.  Subsequently, expands to    the last
           argument    to the previous    command, after expansion.
           Also set    to the full file name of each command executed
           and placed in the environment exported to that command.
           When checking mail, this    parameter holds    the name of
           the mail    file currently being checked.

    SSSShhhheeeellllllll VVVVaaaarrrriiiiaaaabbbblllleeeessss
      The following    variables are set by the shell:

      PPPPPPPPIIIIDDDD The process ID of the shell's parent.  This variable is
           readonly.
      PPPPWWWWDDDD  The current working directory as    set by the ccccdddd command.
      OOOOLLLLDDDDPPPPWWWWDDDD
           The previous working directory as set by    the ccccdddd
           command.
      RRRREEEEPPPPLLLLYYYY
           Set to the line of input    read by    the rrrreeeeaaaadddd builtin
           command when no arguments are supplied.
      UUUUIIIIDDDD  Expands to the user ID of the current user, initialized
           at shell    startup.  This variable    is readonly.
      EEEEUUUUIIIIDDDD Expands to the effective    user ID    of the current user,
           initialized at shell startup.  This variable is
           readonly.
      GGGGRRRROOOOUUUUPPPPSSSS
           An array    variable containing the    list of    groups of
           which the current user is a member.  This variable is
           readonly.
      BBBBAAAASSSSHHHH Expands to the full file    name used to invoke this
           instance    of bbbbaaaasssshhhh.
      BBBBAAAASSSSHHHH____VVVVEEEERRRRSSSSIIIIOOOONNNN
           Expands to a string describing the version of this
           instance    of bbbbaaaasssshhhh.
      BBBBAAAASSSSHHHH____VVVVEEEERRRRSSSSIIIINNNNFFFFOOOO
           A readonly array    variable whose members hold version
           information for this instance of    bbbbaaaasssshhhh.  The values
           assigned    to the array members are as follows:

           BBBBAAAASSSSHHHH____VVVVEEEERRRRSSSSIIIINNNNFFFFOOOO[[[[0]]]]           The major version number    (the
                       _r_e_l_e_a_s_e).
           BBBBAAAASSSSHHHH____VVVVEEEERRRRSSSSIIIINNNNFFFFOOOO[[[[1]]]]           The minor version number    (the
                       _v_e_r_s_i_o_n).
           BBBBAAAASSSSHHHH____VVVVEEEERRRRSSSSIIIINNNNFFFFOOOO[[[[2]]]]           The patch level.
           BBBBAAAASSSSHHHH____VVVVEEEERRRRSSSSIIIINNNNFFFFOOOO[[[[3]]]]           The build version.
           BBBBAAAASSSSHHHH____VVVVEEEERRRRSSSSIIIINNNNFFFFOOOO[[[[4]]]]           The release status (e.g.,
                       _b_e_t_a_1).


     Page 12                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           BBBBAAAASSSSHHHH____VVVVEEEERRRRSSSSIIIINNNNFFFFOOOO[[[[5]]]]           The value of MMMMAAAACCCCHHHHTTTTYYYYPPPPEEEE.

      SSSSHHHHLLLLVVVVLLLL
           Incremented by one each time an instance    of bbbbaaaasssshhhh    is
           started.

      RRRRAAAANNNNDDDDOOOOMMMM
           Each time this parameter    is referenced, a random
           integer between 0 and 32767 is generated.  The sequence
           of random numbers may be    initialized by assigning a
           value to    RRRRAAAANNNNDDDDOOOOMMMM.     If RRRRAAAANNNNDDDDOOOOMMMM is unset, it    loses its
           special properties, even    if it is subsequently reset.

      SSSSEEEECCCCOOOONNNNDDDDSSSS
           Each time this parameter    is referenced, the number of
           seconds since shell invocation is returned.  If a value
           is assigned to SSSSEEEECCCCOOOONNNNDDDDSSSS, the value returned upon
           subsequent references is    the number of seconds since
           the assignment plus the value assigned.    If SSSSEEEECCCCOOOONNNNDDDDSSSS is
           unset, it loses its special properties, even if it is
           subsequently reset.

      LLLLIIIINNNNEEEENNNNOOOO
           Each time this parameter    is referenced, the shell
           substitutes a decimal number representing the current
           sequential line number (starting    with 1)    within a
           script or function.  When not in    a script or function,
           the value substituted is    not guaranteed to be
           meaningful.  If LLLLIIIINNNNEEEENNNNOOOO is unset,    it loses its special
           properties, even    if it is subsequently reset.

      HHHHIIIISSSSTTTTCCCCMMMMDDDD
           The history number, or index in the history list, of
           the current command.  If    HHHHIIIISSSSTTTTCCCCMMMMDDDD    is unset, it loses its
           special properties, even    if it is subsequently reset.

      DDDDIIIIRRRRSSSSTTTTAAAACCCCKKKK
           An array    variable (see AAAArrrrrrrraaaayyyyssss below) containing the
           current contents    of the directory stack.     Directories
           appear in the stack in the order    they are displayed by
           the ddddiiiirrrrssss    builtin.  Assigning to members of this array
           variable    may be used to modify directories already in
           the stack, but the ppppuuuusssshhhhdddd    and ppppooooppppdddd builtins must be used
           to add and remove directories.  Assignment to this
           variable    will not change    the current directory.    If
           DDDDIIIIRRRRSSSSTTTTAAAACCCCKKKK    is unset, it loses its special properties,
           even if it is subsequently reset.

      PPPPIIIIPPPPEEEESSSSTTTTAAAATTTTUUUUSSSS
           An array    variable (see AAAArrrrrrrraaaayyyyssss below) containing a list
           of exit status values from the processes    in the most-
           recently-executed foreground pipeline (which may



     Page 13                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           contain only a single command).

      OOOOPPPPTTTTAAAARRRRGGGG
           The value of the    last option argument processed by the
           ggggeeeettttooooppppttttssss builtin command (see SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS
           below).

      OOOOPPPPTTTTIIIINNNNDDDD
           The index of the    next argument to be processed by the
           ggggeeeettttooooppppttttssss builtin command (see SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS
           below).

      HHHHOOOOSSSSTTTTNNNNAAAAMMMMEEEE
           Automatically set to the    name of    the current host.

      HHHHOOOOSSSSTTTTTTTTYYYYPPPPEEEE
           Automatically set to a string that uniquely describes
           the type    of machine on which bbbbaaaasssshhhh is executing.    The
           default is system-dependent.

      OOOOSSSSTTTTYYYYPPPPEEEE
           Automatically set to a string that describes the
           operating system    on which bbbbaaaasssshhhh is executing.  The
           default is system-dependent.

      MMMMAAAACCCCHHHHTTTTYYYYPPPPEEEE
           Automatically set to a string that fully    describes the
           system type on which bbbbaaaasssshhhh is executing, in the standard
           GNU _c_p_u-_c_o_m_p_a_n_y-_s_y_s_t_e_m format.  The default is system-
           dependent.

      SSSSHHHHEEEELLLLLLLLOOOOPPPPTTTTSSSS
           A colon-separated list of enabled shell options.     Each
           word in the list    is a valid argument for    the ----oooo option
           to the sssseeeetttt builtin command (see SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS
           below).    The options appearing in SSSSHHHHEEEELLLLLLLLOOOOPPPPTTTTSSSS are those
           reported    as _o_n by sssseeeetttt ----oooo.  If this variable is in the
           environment when    bbbbaaaasssshhhh starts up,    each shell option in
           the list    will be    enabled    before reading any startup
           files.  This variable is    read-only.

      The following    variables are used by the shell.  In some
      cases, bbbbaaaasssshhhh assigns a    default    value to a variable; these
      cases    are noted below.

      IIIIFFFFSSSS  The _I_n_t_e_r_n_a_l _F_i_e_l_d _S_e_p_a_r_a_t_o_r that is used for word
           splitting after expansion and to    split lines into words
           with the    rrrreeeeaaaadddd builtin command.  The default value is
           ``<space><tab><newline>''.
      PPPPAAAATTTTHHHH The search path for commands.  It is a colon-separated
           list of directories in which the    shell looks for
           commands    (see CCCCOOOOMMMMMMMMAAAANNNNDDDD EEEEXXXXEEEECCCCUUUUTTTTIIIIOOOONNNN below).    The default



     Page 14                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           path is system-dependent, and is    set by the
           administrator who installs bbbbaaaasssshhhh.     A common value    is
           ``/usr/gnu/bin:/usr/local/bin:/usr/ucb:/bin:/usr/bin:.''.
      HHHHOOOOMMMMEEEE The home    directory of the current user; the default
           argument    for the    ccccdddd builtin command.  The value of this
           variable    is also    used when performing tilde expansion.
      CCCCDDDDPPPPAAAATTTTHHHH
           The search path for the ccccdddd command.  This is a colon-
           separated list of directories in    which the shell    looks
           for destination directories specified by    the ccccdddd
           command.     A sample value    is ``.:~:/usr''.
      BBBBAAAASSSSHHHH____EEEENNNNVVVV
           If this parameter is set    when bbbbaaaasssshhhh is executing a shell
           script, its value is interpreted    as a filename
           containing commands to initialize the shell, as in
           ~/._b_a_s_h_r_c.  The value of    BBBBAAAASSSSHHHH____EEEENNNNVVVV is subjected to
           parameter expansion, command substitution, and
           arithmetic expansion before being interpreted as    a file
           name.  PPPPAAAATTTTHHHH is not used to search for the resultant
           file name.
      MMMMAAAAIIIILLLL If this parameter is set    to a file name and the
           MMMMAAAAIIIILLLLPPPPAAAATTTTHHHH    variable is not    set, bbbbaaaasssshhhh informs the user of
           the arrival of mail in the specified file.
      MMMMAAAAIIIILLLLCCCCHHHHEEEECCCCKKKK
           Specifies how often (in seconds)    bbbbaaaasssshhhh checks for    mail.
           The default is 60 seconds.  When    it is time to check
           for mail, the shell does    so before displaying the
           primary prompt.    If this    variable is unset, the shell
           disables    mail checking.
      MMMMAAAAIIIILLLLPPPPAAAATTTTHHHH
           A colon-separated list of file names to be checked for
           mail. The message to be printed when mail arrives in a
           particular file may be specified    by separating the file
           name from the message with a `?'.  When used in the
           text of the message, $$$$____ expands to the name of the
           current mailfile. Example:
           MMMMAAAAIIIILLLLPPPPAAAATTTTHHHH='/usr/spool/mail/bfox?"You have
           mail":~/shell-mail?"$_ has mail!"'
           BBBBaaaasssshhhh supplies a default value for this variable,    but
           the location of the user    mail files that    it uses    is
           system dependent    (e.g., /usr/spool/mail/$$$$UUUUSSSSEEEERRRR).
      PPPPSSSS1111  The value of this parameter is expanded (see PPPPRRRROOOOMMMMPPPPTTTTIIIINNNNGGGG
           below) and used as the primary prompt string.  The
           default value is    ``\\\\ssss----\\\\vvvv\\\\$$$$ ''.
      PPPPSSSS2222  The value of this parameter is expanded as with PPPPSSSS1111 and
           used as the secondary prompt string.  The default is
           ``>>>> ''.
      PPPPSSSS3333  The value of this parameter is used as the prompt for
           the sssseeeelllleeeecccctttt command (see SSSSHHHHEEEELLLLLLLL GGGGRRRRAAAAMMMMMMMMAAAARRRR above).
      PPPPSSSS4444  The value of this parameter is expanded as with PPPPSSSS1111 and
           the value is printed before each    command    bbbbaaaasssshhhh displays
           during an execution trace.  The first character of PPPPSSSS4444



     Page 15                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           is replicated multiple times, as    necessary, to indicate
           multiple    levels of indirection.    The default is ``++++ ''.
      TTTTIIIIMMMMEEEEFFFFOOOORRRRMMMMAAAATTTT
           The value of this parameter is used as a    format string
           specifying how the timing information for pipelines
           prefixed    with the ttttiiiimmmmeeee reserved word should be
           displayed.  The %%%% character introduces an escape
           sequence    that is    expanded to a time value or other
           information.  The escape    sequences and their meanings
           are as follows; the braces denote optional portions.

           %%%%%%%%     A literal %%%%.
           %%%%[[[[_p]]]][[[[llll]]]]RRRR     The elapsed time in seconds.
           %%%%[[[[_p]]]][[[[llll]]]]UUUU     The number of CPU seconds spent in user mode.
           %%%%[[[[_p]]]][[[[llll]]]]SSSS     The number of CPU seconds spent in system
             mode.
           %%%%PPPP     The CPU percentage, computed as (%U + %S) /
             %R.

           The optional _p is a digit specifying the    _p_r_e_c_i_s_i_o_n, the
           number of fractional digits after a decimal point.  A
           value of    0 causes no decimal point or fraction to be
           output.    At most    three places after the decimal point
           may be specified; values    of _p greater than 3 are
           changed to 3.  If _p is not specified, the value 3 is
           used.

           The optional llll specifies    a longer format, including
           minutes,    of the form _M_Mm_S_S._F_Fs.    The value of _p
           determines whether or not the fraction is included.

           If this variable    is not set, bbbbaaaasssshhhh acts as if it had the
           value $$$$''''\\\\nnnnrrrreeeeaaaallll\\\\tttt%%%%3333llllRRRR\\\\nnnnuuuusssseeeerrrr\\\\tttt%%%%3333llllUUUU\\\\nnnnssssyyyyssss%%%%3333llllSSSS''''.  If the
           value is    null, no timing    information is displayed.  A
           trailing    newline    is added when the format string    is
           displayed.

      HHHHIIIISSSSTTTTSSSSIIIIZZZZEEEE
           The number of commands to remember in the command
           history (see HHHHIIIISSSSTTTTOOOORRRRYYYY below).  The default value is 500.

      HHHHIIIISSSSTTTTFFFFIIIILLLLEEEE
           The name    of the file in which command history is    saved
           (see HHHHIIIISSSSTTTTOOOORRRRYYYY below).  The default value is
           ~/._b_a_s_h__h_i_s_t_o_r_y.     If unset, the command history is not
           saved when an interactive shell exits.

      HHHHIIIISSSSTTTTFFFFIIIILLLLEEEESSSSIIIIZZZZEEEE
           The maximum number of lines contained in    the history
           file.  When this    variable is assigned a value, the
           history file is truncated, if necessary,    to contain no
           more than that number of    lines.    The default value is
           500.  The history file is also truncated    to this    size


     Page 16                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           after writing it    when an    interactive shell exits.

      OOOOPPPPTTTTEEEERRRRRRRR
           If set to the value 1, bbbbaaaasssshhhh displays error messages
           generated by the    ggggeeeettttooooppppttttssss    builtin    command    (see SSSSHHHHEEEELLLLLLLL
           BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS    below).     OOOOPPPPTTTTEEEERRRRRRRR    is initialized to 1
           each time the shell is invoked or a shell script    is
           executed.

      LLLLAAAANNNNGGGG Used to determine the locale category for any category
           not specifically    selected with a    variable starting with
           LLLLCCCC____.

      LLLLCCCC____AAAALLLLLLLL
           This variable overrides the value of LLLLAAAANNNNGGGG and any other
           LLLLCCCC____ variable specifying a locale    category.

      LLLLCCCC____CCCCOOOOLLLLLLLLAAAATTTTEEEE
           This variable determines    the collation order used when
           sorting the results of pathname expansion, and
           determines the behavior of range    expressions,
           equivalence classes, and    collating sequences within
           pathname    expansion and pattern matching.

      LLLLCCCC____CCCCTTTTYYYYPPPPEEEE
           This variable determines    the interpretation of
           characters and the behavior of character    classes    within
           pathname    expansion and pattern matching.

      LLLLCCCC____MMMMEEEESSSSSSSSAAAAGGGGEEEESSSS
           This variable determines    the locale used    to translate
           double-quoted strings preceded by a $$$$.

      PPPPRRRROOOOMMMMPPPPTTTT____CCCCOOOOMMMMMMMMAAAANNNNDDDD
           If set, the value is executed as    a command prior    to
           issuing each primary prompt.

      IIIIGGGGNNNNOOOORRRREEEEEEEEOOOOFFFF
           Controls    the action of an interactive shell on receipt
           of an EEEEOOOOFFFF character as the sole input.  If set, the
           value is    the number of consecutive EEEEOOOOFFFF characters which
           must be typed as    the first characters on    an input line
           before bbbbaaaasssshhhh exits.  If the variable exists but does not
           have a numeric value, or    has no value, the default
           value is    10.  If    it does    not exist, EEEEOOOOFFFF signifies the
           end of input to the shell.

      TTTTMMMMOOOOUUUUTTTT
           If set to a value greater than zero, the    value is
           interpreted as the number of seconds to wait for    input
           after issuing the primary prompt.  BBBBaaaasssshhhh terminates
           after waiting for that number of    seconds    if input does



     Page 17                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           not arrive.

      FFFFCCCCEEEEDDDDIIIITTTT
           The default editor for the ffffcccc builtin command.

      FFFFIIIIGGGGNNNNOOOORRRREEEE
           A colon-separated list of suffixes to ignore when
           performing filename completion (see RRRREEEEAAAADDDDLLLLIIIINNNNEEEE below).  A
           filename    whose suffix matches one of the    entries    in
           FFFFIIIIGGGGNNNNOOOORRRREEEE is excluded from    the list of matched filenames.
           A sample    value is ``.o:~''.

      GGGGLLLLOOOOBBBBIIIIGGGGNNNNOOOORRRREEEE
           A colon-separated list of patterns defining the set of
           filenames to be ignored by pathname expansion.  If a
           filename    matched    by a pathname expansion    pattern    also
           matches one of the patterns in GGGGLLLLOOOOBBBBIIIIGGGGNNNNOOOORRRREEEE, it is
           removed from the    list of    matches.

      IIIINNNNPPPPUUUUTTTTRRRRCCCC
           The filename for    the rrrreeeeaaaaddddlllliiiinnnneeee startup file, overriding
           the default of ~/._i_n_p_u_t_r_c (see RRRREEEEAAAADDDDLLLLIIIINNNNEEEE below).

      HHHHIIIISSSSTTTTCCCCOOOONNNNTTTTRRRROOOOLLLL
           If set to a value of _i_g_n_o_r_e_s_p_a_c_e, lines which begin
           with a ssssppppaaaacccceeee character are not entered on the history
           list.  If set to    a value    of _i_g_n_o_r_e_d_u_p_s, lines matching
           the last    history    line are not entered.  A value of
           _i_g_n_o_r_e_b_o_t_h combines the two options.  If    unset, or if
           set to any other    value than those above,    all lines read
           by the parser are saved on the history list, subject to
           the value of HHHHIIIISSSSTTTTIIIIGGGGNNNNOOOORRRREEEE.     This variable's function is
           superseded by HHHHIIIISSSSTTTTIIIIGGGGNNNNOOOORRRREEEE.  The second and subsequent
           lines of    a multi-line compound command are not tested,
           and are added to    the history regardless of the value of
           HHHHIIIISSSSTTTTCCCCOOOONNNNTTTTRRRROOOOLLLL.

      HHHHIIIISSSSTTTTIIIIGGGGNNNNOOOORRRREEEE
           A colon-separated list of patterns used to decide which
           command lines should be saved on    the history list.
           Each pattern is anchored    at the beginning of the    line
           and must    fully specify the line (no implicit `****'    is
           appended).  Each    pattern    is tested against the line
           after the checks    specified by HHHHIIIISSSSTTTTCCCCOOOONNNNTTTTRRRROOOOLLLL are applied.
           In addition to the normal shell pattern matching
           characters, `&&&&' matches the previous history line.  `&&&&'
           may be escaped using a backslash.  The backslash    is
           removed before attempting a match.  The second and
           subsequent lines    of a multi-line    compound command are
           not tested, and are added to the    history    regardless of
           the value of HHHHIIIISSSSTTTTIIIIGGGGNNNNOOOORRRREEEE.




     Page 18                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      hhhhiiiissssttttcccchhhhaaaarrrrssss
           The two or three    characters which control history
           expansion and tokenization (see HHHHIIIISSSSTTTTOOOORRRRYYYY EEEEXXXXPPPPAAAANNNNSSSSIIIIOOOONNNN
           below).    The first character is the _h_i_s_t_o_r_y _e_x_p_a_n_s_i_o_n
           _c_h_a_r_a_c_t_e_r, the character    which signals the start    of a
           history expansion, normally `!!!!'.     The second character
           is the _q_u_i_c_k _s_u_b_s_t_i_t_u_t_i_o_n character, which is used as
           shorthand for re-running    the previous command entered,
           substituting one    string for another in the command.
           The default is `^^^^'.  The    optional third character is
           the character which indicates that the remainder    of the
           line is a comment when found as the first character of
           a word, normally    `####'.  The history comment character
           causes history substitution to be skipped for the
           remaining words on the line.  It    does not necessarily
           cause the shell parser to treat the rest    of the line as
           a comment.

      HHHHOOOOSSSSTTTTFFFFIIIILLLLEEEE
           Contains    the name of a file in the same format as
           /_e_t_c/_h_o_s_t_s that should be read when the shell needs to
           complete    a hostname.  The file may be changed
           interactively; the next time hostname completion    is
           attempted bbbbaaaasssshhhh adds the contents    of the new file    to the
           already existing    database.

      aaaauuuuttttoooo____rrrreeeessssuuuummmmeeee
           This variable controls how the shell interacts with the
           user and    job control.  If this variable is set, single
           word simple commands without redirections are treated
           as candidates for resumption of an existing stopped
           job.  There is no ambiguity allowed; if there is    more
           than one    job beginning with the string typed, the job
           most recently accessed is selected.  The    _n_a_m_e of    a
           stopped job, in this context, is    the command line used
           to start    it.  If    set to the value _e_x_a_c_t,    the string
           supplied    must match the name of a stopped job exactly;
           if set to _s_u_b_s_t_r_i_n_g, the    string supplied    needs to match
           a substring of the name of a stopped job.  The
           _s_u_b_s_t_r_i_n_g value provides    functionality analogous    to the
           %%%%???? job identifier (see JJJJOOOOBBBB CCCCOOOONNNNTTTTRRRROOOOLLLL below).  If set to
           any other value,    the supplied string must be a prefix
           of a stopped job's name;    this provides functionality
           analogous to the    %%%% job identifier.

    AAAArrrrrrrraaaayyyyssss
      BBBBaaaasssshhhh provides    one-dimensional    array variables.  Any variable
      may be used as an array; the ddddeeeeccccllllaaaarrrreeee builtin will explicitly
      declare an array.  There is no maximum limit on the size of
      an array, nor    any requirement    that members be    indexed    or
      assigned contiguously.  Arrays are indexed using integers
      and are zero-based.



     Page 19                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      An array is created automatically if any variable is
      assigned to using the    syntax _n_a_m_e[_s_u_b_s_c_r_i_p_t]=_v_a_l_u_e.  The
      _s_u_b_s_c_r_i_p_t is treated as an arithmetic    expression that    must
      evaluate to a    number greater than or equal to    zero.  To
      explicitly declare an    array, use ddddeeeeccccllllaaaarrrreeee ----aaaa _n_a_m_e (see    SSSSHHHHEEEELLLLLLLL
      BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below).  ddddeeeeccccllllaaaarrrreeee ----aaaa _n_a_m_e[[[[_s_u_b_s_c_r_i_p_t]]]] is also
      accepted; the    _s_u_b_s_c_r_i_p_t is ignored.  Attributes may be
      specified for    an array variable using    the ddddeeeeccccllllaaaarrrreeee and
      rrrreeeeaaaaddddoooonnnnllllyyyy builtins.  Each attribute applies to    all members of
      an array.

      Arrays are assigned to using compound    assignments of the
      form _n_a_m_e=((((value_1 ...    value_n)))), where each _v_a_l_u_e is of    the
      form [_s_u_b_s_c_r_i_p_t]=_s_t_r_i_n_g.  Only _s_t_r_i_n_g    is required.  If the
      optional brackets and    subscript are supplied,    that index is
      assigned to; otherwise the index of the element assigned is
      the last index assigned to by    the statement plus one.
      Indexing starts at zero.  This syntax    is also    accepted by
      the ddddeeeeccccllllaaaarrrreeee builtin.    Individual array elements may be
      assigned to using the    _n_a_m_e[_s_u_b_s_c_r_i_p_t]=_v_a_l_u_e syntax
      introduced above.

      Any element of an array may be referenced using
      ${_n_a_m_e[_s_u_b_s_c_r_i_p_t]}.  The braces are required to avoid
      conflicts with pathname expansion.  If _s_u_b_s_c_r_i_p_t is @@@@    or ****,
      the word expands to all members of _n_a_m_e.  These subscripts
      differ only when the word appears within double quotes.  If
      the word is double-quoted, ${_n_a_m_e[*]}    expands    to a single
      word with the    value of each array member separated by    the
      first    character of the IIIIFFFFSSSS special variable, and ${_n_a_m_e[@]}
      expands each element of _n_a_m_e to a separate word.  When there
      are no array members,    ${_n_a_m_e[@]} expands to nothing.    This
      is analogous to the expansion    of the special parameters ****
      and @@@@    (see SSSSppppeeeecccciiiiaaaallll PPPPaaaarrrraaaammmmeeeetttteeeerrrrssss    above).     ${#_n_a_m_e[_s_u_b_s_c_r_i_p_t]}
      expands to the length    of ${_n_a_m_e[_s_u_b_s_c_r_i_p_t]}.    If _s_u_b_s_c_r_i_p_t
      is **** or @@@@, the expansion is the number of elements in    the
      array.  Referencing an array variable    without    a subscript is
      equivalent to    referencing element zero.

      The uuuunnnnsssseeeetttt builtin is used to destroy arrays.    uuuunnnnsssseeeetttt
      nnnnaaaammmmeeee[_s_u_b_s_c_r_i_p_t] destroys the array element at    index
      _s_u_b_s_c_r_i_p_t.  uuuunnnnsssseeeetttt _n_a_m_e, where    _n_a_m_e is    an array, or uuuunnnnsssseeeetttt
      _n_a_m_e[_s_u_b_s_c_r_i_p_t], where _s_u_b_s_c_r_i_p_t is ****    or @@@@, removes the
      entire array.

      The ddddeeeeccccllllaaaarrrreeee, llllooooccccaaaallll, and rrrreeeeaaaaddddoooonnnnllllyyyy builtins each accept    a ----aaaa
      option to specify an array.  The rrrreeeeaaaadddd    builtin    accepts    a ----aaaa
      option to assign a list of words read    from the standard
      input    to an array.  The sssseeeetttt and ddddeeeeccccllllaaaarrrreeee builtins display
      array    values in a way    that allows them to be reused as
      assignments.




     Page 20                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



     EEEEXXXXPPPPAAAANNNNSSSSIIIIOOOONNNN
      Expansion is performed on the    command    line after it has been
      split    into words.  There are seven kinds of expansion
      performed:  _b_r_a_c_e _e_x_p_a_n_s_i_o_n, _t_i_l_d_e _e_x_p_a_n_s_i_o_n,    _p_a_r_a_m_e_t_e_r _a_n_d
      _v_a_r_i_a_b_l_e _e_x_p_a_n_s_i_o_n, _c_o_m_m_a_n_d _s_u_b_s_t_i_t_u_t_i_o_n, _a_r_i_t_h_m_e_t_i_c
      _e_x_p_a_n_s_i_o_n, _w_o_r_d _s_p_l_i_t_t_i_n_g, and _p_a_t_h_n_a_m_e _e_x_p_a_n_s_i_o_n.

      The order of expansions is: brace expansion, tilde
      expansion, parameter,    variable and arithmetic    expansion and
      command substitution (done in    a left-to-right    fashion), word
      splitting, and pathname expansion.

      On systems that can support it, there    is an additional
      expansion available: _p_r_o_c_e_s_s _s_u_b_s_t_i_t_u_t_i_o_n.

      Only brace expansion,    word splitting,    and pathname expansion
      can change the number    of words of the    expansion; other
      expansions expand a single word to a single word.  The only
      exceptions to    this are the expansions    of "$$$$@@@@"    and
      "$$$${{{{_n_a_m_e[[[[@@@@]]]]}}}}" as explained above (see PPPPAAAARRRRAAAAMMMMEEEETTTTEEEERRRRSSSS).

    BBBBrrrraaaacccceeee EEEExxxxppppaaaannnnssssiiiioooonnnn
      _B_r_a_c_e    _e_x_p_a_n_s_i_o_n is a mechanism by which arbitrary strings
      may be generated.  This mechanism is similar to _p_a_t_h_n_a_m_e
      _e_x_p_a_n_s_i_o_n, but the filenames generated need not exist.
      Patterns to be brace expanded    take the form of an optional
      _p_r_e_a_m_b_l_e, followed by    a series of comma-separated strings
      between a pair of braces, followed by    an optional
      _p_o_s_t_s_c_r_i_p_t.  The preamble is prefixed    to each    string
      contained within the braces, and the postscript is then
      appended to each resulting string, expanding left to right.

      Brace    expansions may be nested.  The results of each
      expanded string are not sorted; left to right    order is
      preserved.  For example, a{{{{d,c,b}}}}e expands into `ade ace
      abe'.

      Brace    expansion is performed before any other    expansions,
      and any characters special to    other expansions are preserved
      in the result.  It is    strictly textual.  BBBBaaaasssshhhh    does not apply
      any syntactic    interpretation to the context of the expansion
      or the text between the braces.

      A correctly-formed brace expansion must contain unquoted
      opening and closing braces, and at least one unquoted    comma.
      Any incorrectly formed brace expansion is left unchanged.  A
      {{{{ or ,,,, may be    quoted with a backslash    to prevent its being
      considered part of a brace expression.

      This construct is typically used as shorthand    when the
      common prefix    of the strings to be generated is longer than
      in the above example:



     Page 21                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           mkdir /usr/local/src/bash/{old,new,dist,bugs}
      or
           chown root /usr/{ucb/{ex,edit},lib/{ex?.?*,how_ex}}

      Brace    expansion introduces a slight incompatibility with
      historical versions of sssshhhh.  sssshhhh does not treat    opening    or
      closing braces specially when    they appear as part of a word,
      and preserves    them in    the output.  BBBBaaaasssshhhh removes braces from
      words    as a consequence of brace expansion.  For example, a
      word entered to sssshhhh as    _f_i_l_e{_1,_2} appears identically in the
      output.  The same word is output as _f_i_l_e_1 _f_i_l_e_2 after
      expansion by bbbbaaaasssshhhh.  If strict    compatibility with sssshhhh is
      desired, start bbbbaaaasssshhhh with the ++++BBBB option or disable brace
      expansion with the ++++BBBB    option to the sssseeeetttt command (see SSSSHHHHEEEELLLLLLLL
      BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below).

    TTTTiiiillllddddeeee EEEExxxxppppaaaannnnssssiiiioooonnnn
      If a word begins with    an unquoted tilde character (`~~~~'), all
      of the characters preceding the first    unquoted slash (or all
      characters, if there is no unquoted slash) are considered a
      _t_i_l_d_e-_p_r_e_f_i_x.     If none of the    characters in the tilde-prefix
      are quoted, the characters in    the tilde-prefix following the
      tilde    are treated as a possible _l_o_g_i_n    _n_a_m_e.  If this login
      name is the null string, the tilde is    replaced with the
      value    of the shell parameter HHHHOOOOMMMMEEEE.  If HHHHOOOOMMMMEEEE is unset,    the
      home directory of the    user executing the shell is
      substituted instead.    Otherwise, the tilde-prefix is
      replaced with    the home directory associated with the
      specified login name.

      If the tilde-prefix is a `~+', the value of the shell
      variable PPPPWWWWDDDD replaces    the tilde-prefix.  If the tilde-prefix
      is a `~-', the value of the shell variable OOOOLLLLDDDDPPPPWWWWDDDD, if    it is
      set, is substituted.    If the characters following the    tilde
      in the tilde-prefix consist of a number _N, optionally
      prefixed by a    `+' or a `-', the tilde-prefix is replaced
      with the corresponding element from the directory stack, as
      it would be displayed    by the ddddiiiirrrrssss builtin invoked with the
      tilde-prefix as an argument.    If the characters following
      the tilde in the tilde-prefix    consist    of a number without a
      leading `+' or `-', `+' is assumed.

      If the login name is invalid,    or the tilde expansion fails,
      the word is unchanged.

      Each variable    assignment is checked for unquoted tilde-
      prefixes immediately following a :::: or    ====.  In these cases,
      tilde    expansion is also performed.  Consequently, one    may
      use file names with tildes in    assignments to PPPPAAAATTTTHHHH, MMMMAAAAIIIILLLLPPPPAAAATTTTHHHH,
      and CCCCDDDDPPPPAAAATTTTHHHH, and the shell assigns the    expanded value.

    PPPPaaaarrrraaaammmmeeeetttteeeerrrr EEEExxxxppppaaaannnnssssiiiioooonnnn



     PPPPaaaaggggeeee 22222222                         ((((pppprrrriiiinnnntttteeeedddd 3333////22225555////99999999))))






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      The `$$$$' character introduces parameter expansion, command
      substitution,    or arithmetic expansion.  The parameter    name
      or symbol to be expanded may be enclosed in braces, which
      are optional but serve to protect the    variable to be
      expanded from    characters immediately following it which
      could    be interpreted as part of the name.

      When braces are used,    the matching ending brace is the first
      `}}}}' not escaped by a backslash or within a quoted string,
      and not within an embedded arithmetic    expansion, command
      substitution,    or paramter expansion.

      ${_p_a_r_a_m_e_t_e_r}
           The value of _p_a_r_a_m_e_t_e_r is substituted.  The braces are
           required    when _p_a_r_a_m_e_t_e_r is a positional parameter with
           more than one digit, or when _p_a_r_a_m_e_t_e_r is followed by a
           character which is not to be interpreted    as part    of its
           name.

      If the first character of _p_a_r_a_m_e_t_e_r is an exclamation    point,
      a level of variable indirection is introduced.  BBBBaaaasssshhhh uses
      the value of the variable formed from    the rest of _p_a_r_a_m_e_t_e_r
      as the name of the variable; this variable is    then expanded
      and that value used in the rest of the substitution, rather
      than the value of _p_a_r_a_m_e_t_e_r itself.  This is known as
      _i_n_d_i_r_e_c_t _e_x_p_a_n_s_i_o_n.

      In each of the cases below, _w_o_r_d is subject to tilde
      expansion, parameter expansion, command substitution,    and
      arithmetic expansion.     When not performing substring
      expansion, bbbbaaaasssshhhh tests    for a parameter    that is    unset or null;
      omitting the colon results in    a test only for    a parameter
      that is unset.

      ${_p_a_r_a_m_e_t_e_r::::----_w_o_r_d}
           UUUUsssseeee DDDDeeeeffffaaaauuuulllltttt VVVVaaaalllluuuueeeessss.  If _p_a_r_a_m_e_t_e_r is unset or null, the
           expansion of _w_o_r_d is substituted.  Otherwise, the value
           of _p_a_r_a_m_e_t_e_r is substituted.
      ${_p_a_r_a_m_e_t_e_r::::====_w_o_r_d}
           AAAAssssssssiiiiggggnnnn DDDDeeeeffffaaaauuuulllltttt VVVVaaaalllluuuueeeessss.  If _p_a_r_a_m_e_t_e_r is unset or    null,
           the expansion of    _w_o_r_d is    assigned to _p_a_r_a_m_e_t_e_r.    The
           value of    _p_a_r_a_m_e_t_e_r is then substituted.    Positional
           parameters and special parameters may not be assigned
           to in this way.
      ${_p_a_r_a_m_e_t_e_r::::????_w_o_r_d}
           DDDDiiiissssppppllllaaaayyyy EEEErrrrrrrroooorrrr iiiiffff    NNNNuuuullllllll oooorrrr    UUUUnnnnsssseeeetttt.    If _p_a_r_a_m_e_t_e_r is    null
           or unset, the expansion of _w_o_r_d (or a message to    that
           effect if _w_o_r_d is not present) is written to the
           standard    error and the shell, if    it is not interactive,
           exits.  Otherwise, the value of _p_a_r_a_m_e_t_e_r is
           substituted.
      ${_p_a_r_a_m_e_t_e_r::::++++_w_o_r_d}



     Page 23                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           UUUUsssseeee AAAAlllltttteeeerrrrnnnnaaaatttteeee VVVVaaaalllluuuueeee.  If    _p_a_r_a_m_e_t_e_r is null or unset,
           nothing is substituted, otherwise the expansion of _w_o_r_d
           is substituted.
      ${_p_a_r_a_m_e_t_e_r::::_o_f_f_s_e_t}
      ${_p_a_r_a_m_e_t_e_r::::_o_f_f_s_e_t::::_l_e_n_g_t_h}
           SSSSuuuubbbbssssttttrrrriiiinnnngggg EEEExxxxppppaaaannnnssssiiiioooonnnn....  Expands to    up to _l_e_n_g_t_h
           characters of _p_a_r_a_m_e_t_e_r,    starting at the    characters
           specified by _o_f_f_s_e_t.  If    _l_e_n_g_t_h is omitted, expands to
           the substring of    _p_a_r_a_m_e_t_e_r, starting at the character
           specified by _o_f_f_s_e_t.  _l_e_n_g_t_h and    _o_f_f_s_e_t are arithmetic
           expressions (see    AAAARRRRIIIITTTTHHHHMMMMEEEETTTTIIIICCCC EEEEVVVVAAAALLLLUUUUAAAATTTTIIIIOOOONNNN below).  _l_e_n_g_t_h
           must evaluate to    a number greater than or equal to
           zero.  If _o_f_f_s_e_t    evaluates to a number less than    zero,
           the value is used as an offset from the end of the
           value of    _p_a_r_a_m_e_t_e_r.  If _p_a_r_a_m_e_t_e_r is @@@@, the result is
           _l_e_n_g_t_h positional parameters beginning at _o_f_f_s_e_t.  If
           _p_a_r_a_m_e_t_e_r is an array name indexed by @ or *, the
           result is the _l_e_n_g_t_h members of the array beginning
           with ${_p_a_r_a_m_e_t_e_r[_o_f_f_s_e_t]}.  Substring indexing is
           zero-based unless the positional    parameters are used,
           in which    case the indexing starts at 1.

      ${####_p_a_r_a_m_e_t_e_r}
           The length in characters    of the value of    _p_a_r_a_m_e_t_e_r is
           substituted.  If    _p_a_r_a_m_e_t_e_r is **** or @@@@, the value
           substituted is the number of positional parameters.  If
           _p_a_r_a_m_e_t_e_r is an array name subscripted by **** or @@@@, the
           value substituted is the    number of elements in the
           array.

      ${_p_a_r_a_m_e_t_e_r####_w_o_r_d}
      ${_p_a_r_a_m_e_t_e_r########_w_o_r_d}
           The _w_o_r_d    is expanded to produce a pattern just as in
           pathname    expansion.  If the pattern matches the
           beginning of the    value of _p_a_r_a_m_e_t_e_r, then the result of
           the expansion is    the expanded value of _p_a_r_a_m_e_t_e_r    with
           the shortest matching pattern (the ``####''    case) or the
           longest matching    pattern    (the ``########'' case) deleted.  If
           _p_a_r_a_m_e_t_e_r is @@@@ or ****, the    pattern    removal    operation is
           applied to each positional parameter in turn, and the
           expansion is the    resultant list.     If _p_a_r_a_m_e_t_e_r is an
           array variable subscripted with @@@@ or ****, the pattern
           removal operation is applied to each member of the
           array in    turn, and the expansion    is the resultant list.

      ${_p_a_r_a_m_e_t_e_r%%%%_w_o_r_d}
      ${_p_a_r_a_m_e_t_e_r%%%%%%%%_w_o_r_d}
           The _w_o_r_d    is expanded to produce a pattern just as in
           pathname    expansion.  If the pattern matches a trailing
           portion of the expanded value of    _p_a_r_a_m_e_t_e_r, then    the
           result of the expansion is the expanded value of
           _p_a_r_a_m_e_t_e_r with the shortest matching pattern (the ``%%%%''



     Page 24                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           case) or    the longest matching pattern (the ``%%%%%%%%'' case)
           deleted.     If _p_a_r_a_m_e_t_e_r is @@@@ or ****, the pattern removal
           operation is applied to each positional parameter in
           turn, and the expansion is the resultant    list.  If
           _p_a_r_a_m_e_t_e_r is an array variable subscripted with @@@@ or ****,
           the pattern removal operation is    applied    to each    member
           of the array in turn, and the expansion is the
           resultant list.

      ${_p_a_r_a_m_e_t_e_r////_p_a_t_t_e_r_n////_s_t_r_i_n_g}
      ${_p_a_r_a_m_e_t_e_r////////_p_a_t_t_e_r_n////_s_t_r_i_n_g}
           The _p_a_t_t_e_r_n is expanded to produce a pattern just as in
           pathname    expansion.  _P_a_r_a_m_e_t_e_r is expanded and the
           longest match of    _p_a_t_t_e_r_n    against    its value is replaced
           with _s_t_r_i_n_g.  In    the first form,    only the first match
           is replaced.  The second    form causes all    matches    of
           _p_a_t_t_e_r_n to be replaced with _s_t_r_i_n_g.  If _p_a_t_t_e_r_n begins
           with ####, it must match at    the beginning of the expanded
           value of    _p_a_r_a_m_e_t_e_r.  If _p_a_t_t_e_r_n begins with %%%%, it must
           match at    the end    of the expanded    value of _p_a_r_a_m_e_t_e_r.
           If _s_t_r_i_n_g is null, matches of _p_a_t_t_e_r_n are deleted and
           the //// following _p_a_t_t_e_r_n may be omitted.    If _p_a_r_a_m_e_t_e_r
           is @@@@ or ****, the substitution operation is    applied    to
           each positional parameter in turn, and the expansion is
           the resultant list.  If _p_a_r_a_m_e_t_e_r is an array variable
           subscripted with    @@@@ or ****,    the substitution operation is
           applied to each member of the array in turn, and    the
           expansion is the    resultant list.

    CCCCoooommmmmmmmaaaannnndddd    SSSSuuuubbbbssssttttiiiittttuuuuttttiiiioooonnnn
      _C_o_m_m_a_n_d _s_u_b_s_t_i_t_u_t_i_o_n allows the output of a command to
      replace the command name.  There are two forms:

           $$$$((((_c_o_m_m_a_n_d))))
      or
           ````_c_o_m_m_a_n_d````

      BBBBaaaasssshhhh performs    the expansion by executing _c_o_m_m_a_n_d and
      replacing the    command    substitution with the standard output
      of the command, with any trailing newlines deleted.
      Embedded newlines are    not deleted, but they may be removed
      during word splitting.  The command substitution $$$$((((ccccaaaatttt _f_i_l_e))))
      can be replaced by the equivalent but    faster $$$$((((<<<< _f_i_l_e)))).

      When the old-style backquote form of substitution is used,
      backslash retains its    literal    meaning    except when followed
      by $$$$,    ````, or \\\\.  The first backquote not preceded by a
      backslash terminates the command substitution.  When using
      the $(_c_o_m_m_a_n_d) form, all characters between the parentheses
      make up the command; none are    treated    specially.

      Command substitutions    may be nested.    To nest    when using the



     Page 25                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      backquoted form, escape the inner backquotes with
      backslashes.

      If the substitution appears within double quotes, word
      splitting and    pathname expansion are not performed on    the
      results.

    AAAArrrriiiitttthhhhmmmmeeeettttiiiicccc EEEExxxxppppaaaannnnssssiiiioooonnnn
      Arithmetic expansion allows the evaluation of    an arithmetic
      expression and the substitution of the result.  The format
      for arithmetic expansion is:

           $$$$((((((((_e_x_p_r_e_s_s_i_o_n))))))))

      The _e_x_p_r_e_s_s_i_o_n is treated as if it were within double
      quotes, but a    double quote inside the    parentheses is not
      treated specially.  All tokens in the    expression undergo
      parameter expansion, string expansion, command substitution,
      and quote removal.  Arithmetic substitutions may be nested.

      The evaluation is performed according    to the rules listed
      below    under AAAARRRRIIIITTTTHHHHMMMMEEEETTTTIIIICCCC EEEEVVVVAAAALLLLUUUUAAAATTTTIIIIOOOONNNN.  If _e_x_p_r_e_s_s_i_o_n is
      invalid, bbbbaaaasssshhhh    prints a message indicating failure and    no
      substitution occurs.

    PPPPrrrroooocccceeeessssssss    SSSSuuuubbbbssssttttiiiittttuuuuttttiiiioooonnnn
      _P_r_o_c_e_s_s _s_u_b_s_t_i_t_u_t_i_o_n is supported on systems that support
      named    pipes (_F_I_F_O_s) or the ////ddddeeeevvvv////ffffdddd method of naming open
      files.  It takes the form of <<<<((((_l_i_s_t)))) or >>>>((((_l_i_s_t)))).  The
      process _l_i_s_t is run with its input or    output connected to a
      _F_I_F_O or some file in ////ddddeeeevvvv////ffffdddd.     The name of this file is
      passed as an argument    to the current command as the result
      of the expansion.  If    the >>>>((((_l_i_s_t)))) form is used, writing to
      the file will    provide    input for _l_i_s_t.     If the    <<<<((((_l_i_s_t))))    form
      is used, the file passed as an argument should be read to
      obtain the output of _l_i_s_t.

      When available, _p_r_o_c_e_s_s _s_u_b_s_t_i_t_u_t_i_o_n is performed
      simultaneously with parameter    and variable expansion,
      command substitution,    and arithmetic expansion.

    WWWWoooorrrrdddd SSSSpppplllliiiittttttttiiiinnnngggg
      The shell scans the results of parameter expansion, command
      substitution,    and arithmetic expansion that did not occur
      within double    quotes for _w_o_r_d    _s_p_l_i_t_t_i_n_g.

      The shell treats each    character of IIIIFFFFSSSS as a delimiter, and
      splits the results of    the other expansions into words    on
      these    characters.  If    IIIIFFFFSSSS is unset, or its value is exactly
      <<<<ssssppppaaaacccceeee>>>><<<<ttttaaaabbbb>>>><<<<nnnneeeewwwwlllliiiinnnneeee>>>>, the default, then any sequence    of IIIIFFFFSSSS
      characters serves to delimit words.  If IIIIFFFFSSSS has a value
      other    than the default, then sequences of the    whitespace



     Page 26                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      characters ssssppppaaaacccceeee and ttttaaaabbbb are ignored at the beginning    and
      end of the word, as long as the whitespace character is in
      the value of IIIIFFFFSSSS (an IIIIFFFFSSSS whitespace character).  Any
      character in IIIIFFFFSSSS that    is not IIIIFFFFSSSS whitespace, along with any
      adjacent IIIIFFFFSSSS whitespace characters, delimits a field.     A
      sequence of IIIIFFFFSSSS whitespace characters    is also    treated    as a
      delimiter.  If the value of IIIIFFFFSSSS is null, no word splitting
      occurs.

      Explicit null    arguments ("""""""" or '''''''') are retained.  Unquoted
      implicit null    arguments, resulting from the expansion    of
      _p_a_r_a_m_e_t_e_r_s that have no values, are removed.    If a parameter
      with no value    is expanded within double quotes, a null
      argument results and is retained.

      Note that if no expansion occurs, no splitting is performed.

    PPPPaaaatttthhhhnnnnaaaammmmeeee EEEExxxxppppaaaannnnssssiiiioooonnnn
      After    word splitting,    unless the ----ffff option has been set,
      bbbbaaaasssshhhh scans each word for the characters ****, ????,    ((((, and [[[[.  If
      one of these characters appears, then    the word is regarded
      as a _p_a_t_t_e_r_n,    and replaced with an alphabetically sorted
      list of file names matching the pattern.  If no matching
      file names are found,    and the    shell option nnnnuuuullllllllgggglllloooobbbb is
      disabled, the    word is    left unchanged.     If the    nnnnuuuullllllllgggglllloooobbbb
      option is set, and no    matches    are found, the word is
      removed.  If the shell option    nnnnooooccccaaaasssseeeegggglllloooobbbb is enabled, the
      match    is performed without regard to the case    of alphabetic
      characters.  When a pattern is used for pathname expansion,
      the character    ````````....'''''''' at the start of a    name or    immediately
      following a slash must be matched explicitly,    unless the
      shell    option ddddoooottttgggglllloooobbbb is set.    When matching a    pathname, the
      slash    character must always be matched explicitly.  In other
      cases, the ````````....'''''''' character is    not treated specially.    See
      the description of sssshhhhoooopppptttt below under SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS
      for a    description of the nnnnooooccccaaaasssseeeegggglllloooobbbb, nnnnuuuullllllllgggglllloooobbbb, and ddddoooottttgggglllloooobbbb
      shell    options.

      The GGGGLLLLOOOOBBBBIIIIGGGGNNNNOOOORRRREEEE shell variable    may be used to restrict    the
      set of file names matching a _p_a_t_t_e_r_n.     If GGGGLLLLOOOOBBBBIIIIGGGGNNNNOOOORRRREEEE is set,
      each matching    file name that also matches one    of the
      patterns in GGGGLLLLOOOOBBBBIIIIGGGGNNNNOOOORRRREEEE is removed from the list of matches.
      The file names ````````....'''''''' and ````````........'''''''' are always ignored, even
      when GGGGLLLLOOOOBBBBIIIIGGGGNNNNOOOORRRREEEE is set.  However, setting GGGGLLLLOOOOBBBBIIIIGGGGNNNNOOOORRRREEEE has the
      effect of enabling the ddddoooottttgggglllloooobbbb shell option, so all other
      file names beginning with a ````````....'''''''' will match.     To get    the
      old behavior of ignoring file    names beginning    with a ````````....'''''''',
      make ````````....****'''''''' one of the patterns in GGGGLLLLOOOOBBBBIIIIGGGGNNNNOOOORRRREEEE.  The ddddoooottttgggglllloooobbbb
      option is disabled when GGGGLLLLOOOOBBBBIIIIGGGGNNNNOOOORRRREEEE is    unset.

      PPPPaaaatttttttteeeerrrrnnnn MMMMaaaattttcccchhhhiiiinnnngggg




     Page 27                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      Any character    that appears in    a pattern, other than the
      special pattern characters described below, matches itself.
      The NUL character may    not occur in a pattern.     The special
      pattern characters must be quoted if they are    to be matched
      literally.

      The special pattern characters have the following meanings:

      ****    Matches any string, including the null string.
      ????    Matches any single character.
      [[[[............]]]]
           Matches any one of the enclosed characters.  A pair of
           characters separated by a minus sign denotes a _r_a_n_g_e;
           any character lexically between those two characters,
           inclusive, is matched.  If the first character
           following the [[[[ is a !!!! or a ^^^^ then any character    not
           enclosed    is matched.  A ---- may be    matched    by including
           it as the first or last character in the    set.  A    ]]]] may
           be matched by including it as the first character in
           the set.

           Within [[[[    and ]]]], _c_h_a_r_a_c_t_e_r _c_l_a_s_s_e_s can be    specified
           using the syntax    [[[[::::_c_l_a_s_s::::]]]], where _c_l_a_s_s is one of the
           following classes defined in the    POSIX.2    standard:
           aaaallllnnnnuuuummmm aaaallllpppphhhhaaaa aaaasssscccciiiiiiii bbbbllllaaaannnnkkkk ccccnnnnttttrrrrllll ddddiiiiggggiiiitttt ggggrrrraaaapppphhhh lllloooowwwweeeerrrr pppprrrriiiinnnntttt
           ppppuuuunnnncccctttt ssssppppaaaacccceeee uuuuppppppppeeeerrrr xxxxddddiiiiggggiiiitttt
           A character class matches any character belonging to
           that class.

           Within [[[[    and ]]]], an _e_q_u_i_v_a_l_e_n_c_e _c_l_a_s_s can    be specified
           using the syntax    [[[[====_c====]]]], which matches all characters
           with the    same collation weight (as defined by the
           current locale) as the character    _c.

           Within [[[[    and ]]]], the syntax [[[[...._s_y_m_b_o_l....]]]] matches the
           collating symbol    _s_y_m_b_o_l.

      If the eeeexxxxttttgggglllloooobbbb shell option is enabled using the sssshhhhoooopppptttt
      builtin, several extended pattern matching operators are
      recognized.  In the following    description, a _p_a_t_t_e_r_n-_l_i_s_t is
      a list of one    or more    patterns separated by a    ||||.  Composite
      patterns may be formed using one or more of the following
      sub-patterns:

           ????((((_p_a_t_t_e_r_n-_l_i_s_t))))
            Matches zero or one    occurrence of the given
            patterns
           ****((((_p_a_t_t_e_r_n-_l_i_s_t))))
            Matches zero or more occurrences of    the given
            patterns
           ++++((((_p_a_t_t_e_r_n-_l_i_s_t))))
            Matches one    or more    occurrences of the given



     Page 28                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



            patterns
           @@@@((((_p_a_t_t_e_r_n-_l_i_s_t))))
            Matches exactly one    of the given patterns
           !!!!((((_p_a_t_t_e_r_n-_l_i_s_t))))
            Matches anything except one    of the given patterns

    QQQQuuuuooootttteeee RRRReeeemmmmoooovvvvaaaallll
      After    the preceding expansions, all unquoted occurrences of
      the characters \\\\, '''', and """" that did not result from one of
      the above expansions are removed.

     RRRREEEEDDDDIIIIRRRREEEECCCCTTTTIIIIOOOONNNN
      Before a command is executed,    its input and output may be
      _r_e_d_i_r_e_c_t_e_d using a special notation interpreted by the
      shell.  Redirection may also be used to open and close files
      for the current shell    execution environment.    The following
      redirection operators    may precede or appear anywhere within
      a _s_i_m_p_l_e _c_o_m_m_a_n_d or may follow a _c_o_m_m_a_n_d.  Redirections are
      processed in the order they appear, from left    to right.

      In the following descriptions, if the    file descriptor    number
      is omitted, and the first character of the redirection
      operator is <<<<, the redirection refers    to the standard    input
      (file    descriptor 0).    If the first character of the
      redirection operator is >>>>, the redirection refers to the
      standard output (file    descriptor 1).

      The word following the redirection operator in the following
      descriptions,    unless otherwise noted,    is subjected to    brace
      expansion, tilde expansion, parameter    expansion, command
      substitution,    arithmetic expansion, quote removal, and
      pathname expansion.  If it expands to    more than one word,
      bbbbaaaasssshhhh reports an error.

      Note that the    order of redirections is significant.  For
      example, the command

           ls >>>> dirlist 2>>>>&&&&1

      directs both standard    output and standard error to the file
      _d_i_r_l_i_s_t, while the command

           ls 2>>>>&&&&1 >>>> dirlist

      directs only the standard output to file _d_i_r_l_i_s_t, because
      the standard error was duplicated as standard    output before
      the standard output was redirected to    _d_i_r_l_i_s_t.

      A failure to open or create a    file causes the    redirection to
      fail.

    RRRReeeeddddiiiirrrreeeeccccttttiiiinnnngggg IIIInnnnppppuuuutttt



     PPPPaaaaggggeeee 22229999                         ((((pppprrrriiiinnnntttteeeedddd 3333////22225555////99999999))))






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      Redirection of input causes the file whose name results from
      the expansion    of _w_o_r_d    to be opened for reading on file
      descriptor _n,    or the standard    input (file descriptor 0) if _n
      is not specified.

      The general format for redirecting input is:

           [_n]<<<<_w_o_r_d

    RRRReeeeddddiiiirrrreeeeccccttttiiiinnnngggg OOOOuuuuttttppppuuuutttt
      Redirection of output    causes the file    whose name results
      from the expansion of    _w_o_r_d to    be opened for writing on file
      descriptor _n,    or the standard    output (file descriptor    1) if
      _n is not specified.  If the file does    not exist it is
      created; if it does exist it is truncated to zero size.

      The general format for redirecting output is:

           [_n]>>>>_w_o_r_d

      If the redirection operator is >>>>, and    the nnnnoooocccclllloooobbbbbbbbeeeerrrr option
      to the sssseeeetttt builtin has been enabled, the redirection will
      fail if the filename whose name results from the expansion
      of _w_o_r_d exists and is    a regular file.     If the    redirection
      operator is >>>>||||, or the redirection operator is >>>> and the
      nnnnoooocccclllloooobbbbbbbbeeeerrrr option to the sssseeeetttt builtin command is not enabled,
      the redirection is attempted even if the file    named by _w_o_r_d
      exists.

    AAAAppppppppeeeennnnddddiiiinnnngggg RRRReeeeddddiiiirrrreeeecccctttteeeedddd OOOOuuuuttttppppuuuutttt
      Redirection of output    in this    fashion    causes the file    whose
      name results from the    expansion of _w_o_r_d to be    opened for
      appending on file descriptor _n, or the standard output (file
      descriptor 1)    if _n is    not specified.    If the file does not
      exist    it is created.

      The general format for appending output is:

           [_n]>>>>>>>>_w_o_r_d

    RRRReeeeddddiiiirrrreeeeccccttttiiiinnnngggg SSSSttttaaaannnnddddaaaarrrrdddd OOOOuuuuttttppppuuuutttt aaaannnndddd    SSSSttttaaaannnnddddaaaarrrrdddd EEEErrrrrrrroooorrrr
      BBBBaaaasssshhhh allows both the standard    output (file descriptor    1) and
      the standard error output (file descriptor 2)    to be
      redirected to    the file whose name is the expansion of    _w_o_r_d
      with this construct.

      There    are two    formats    for redirecting    standard output    and
      standard error:

           &&&&>>>>_w_o_r_d
      and
           >>>>&&&&_w_o_r_d



     Page 30                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      Of the two forms, the    first is preferred.  This is
      semantically equivalent to

           >>>>_w_o_r_d 2>>>>&&&&1

    HHHHeeeerrrreeee DDDDooooccccuuuummmmeeeennnnttttssss
      This type of redirection instructs the shell to read input
      from the current source until    a line containing only _w_o_r_d
      (with    no trailing blanks) is seen.  All of the lines read up
      to that point    are then used as the standard input for    a
      command.

      The format of    here-documents is as follows:

           <<<<<<<<[----]_w_o_r_d
               _h_e_r_e-_d_o_c_u_m_e_n_t
           _d_e_l_i_m_i_t_e_r

      No parameter expansion, command substitution,    pathname
      expansion, or    arithmetic expansion is    performed on _w_o_r_d.  If
      any characters in _w_o_r_d are quoted, the _d_e_l_i_m_i_t_e_r is the
      result of quote removal on _w_o_r_d, and the lines in the    here-
      document are not expanded.  If _w_o_r_d is unquoted, all lines
      of the here-document are subjected to    parameter expansion,
      command substitution,    and arithmetic expansion.  In the
      latter case, the pair    \\\\<<<<nnnneeeewwwwlllliiiinnnneeee>>>> is ignored, and \\\\ must be
      used to quote    the characters \\\\, $$$$, and ````.

      If the redirection operator is <<<<<<<<----, then all leading tab
      characters are stripped from input lines and the line
      containing _d_e_l_i_m_i_t_e_r.     This allows here-documents within
      shell    scripts    to be indented in a natural fashion.

    DDDDuuuupppplllliiiiccccaaaattttiiiinnnngggg FFFFiiiilllleeee DDDDeeeessssccccrrrriiiippppttttoooorrrrssss
      The redirection operator

           [_n]<<<<&&&&_w_o_r_d

      is used to duplicate input file descriptors.    If _w_o_r_d
      expands to one or more digits, the file descriptor denoted
      by _n is made to be a copy of that file descriptor.  If the
      digits in _w_o_r_d do not    specify    a file descriptor open for
      input, a redirection error occurs.  If _w_o_r_d evaluates    to ----,
      file descriptor _n is closed.    If _n is    not specified, the
      standard input (file descriptor 0) is    used.

      The operator

           [_n]>>>>&&&&_w_o_r_d

      is used similarly to duplicate output    file descriptors.  If
      _n is not specified, the standard output (file    descriptor 1)



     Page 31                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      is used.  If the digits in _w_o_r_d do not specify a file
      descriptor open for output, a    redirection error occurs.  As
      a special case, if _n is omitted, and _w_o_r_d does not expand to
      one or more digits, the standard output and standard error
      are redirected as described previously.

    OOOOppppeeeennnniiiinnnngggg    FFFFiiiilllleeee DDDDeeeessssccccrrrriiiippppttttoooorrrrssss ffffoooorrrr RRRReeeeaaaaddddiiiinnnngggg aaaannnndddd WWWWrrrriiiittttiiiinnnngggg
      The redirection operator

           [_n]<<<<>>>>_w_o_r_d

      causes the file whose    name is    the expansion of _w_o_r_d to be
      opened for both reading and writing on file descriptor _n, or
      on file descriptor 0 if _n is not specified.  If the file
      does not exist, it is    created.

     AAAALLLLIIIIAAAASSSSEEEESSSS
      Aliases allow    a string to be substituted for a word when it
      is used as the first word of a simple    command.  The shell
      maintains a list of _a_l_i_a_s_e_s that may be set and unset    with
      the aaaalllliiiiaaaassss and    uuuunnnnaaaalllliiiiaaaassss    builtin    commands (see SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN
      CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below).  The    first word of each command, if
      unquoted, is checked to see if it has    an alias.  If so, that
      word is replaced by the text of the alias.  The alias    name
      and the replacement text may contain any valid shell input,
      including the    _m_e_t_a_c_h_a_r_a_c_t_e_r_s listed above, with the
      exception that the alias name    may not    contain    =.  The    first
      word of the replacement text is tested for aliases, but a
      word that is identical to an alias being expanded is not
      expanded a second time.  This    means that one may alias llllssss to
      llllssss ----FFFF, for instance, and bbbbaaaasssshhhh    does not try to    recursively
      expand the replacement text.    If the last character of the
      alias    value is a _b_l_a_n_k, then the next    command    word following
      the alias is also checked for    alias expansion.

      Aliases are created and listed with the aaaalllliiiiaaaassss    command, and
      removed with the uuuunnnnaaaalllliiiiaaaassss command.

      There    is no mechanism    for using arguments in the replacement
      text.     If arguments are needed, a shell function should be
      used.

      Aliases are not expanded when    the shell is not interactive,
      unless the eeeexxxxppppaaaannnndddd____aaaalllliiiiaaaasssseeeessss shell option is set    using sssshhhhoooopppptttt
      (see the description of sssshhhhoooopppptttt    under SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS
      below).

      The rules concerning the definition and use of aliases are
      somewhat confusing.  BBBBaaaasssshhhh always reads at least one complete
      line of input    before executing any of    the commands on    that
      line.     Aliases are expanded when a command is    read, not when
      it is    executed.  Therefore, an alias definition appearing on



     Page 32                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      the same line    as another command does    not take effect    until
      the next line    of input is read.  The commands    following the
      alias    definition on that line    are not    affected by the    new
      alias.  This behavior    is also    an issue when functions    are
      executed.  Aliases are expanded when a function definition
      is read, not when the    function is executed, because a
      function definition is itself    a compound command.  As    a
      consequence, aliases defined in a function are not available
      until    after that function is executed.  To be    safe, always
      put alias definitions    on a separate line, and    do not use
      aaaalllliiiiaaaassss    in compound commands.

      For almost every purpose, aliases are    superseded by shell
      functions.

     FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNNSSSS
      A shell function, defined as described above under SSSSHHHHEEEELLLLLLLL
      GGGGRRRRAAAAMMMMMMMMAAAARRRR, stores a series of commands for later execution.
      Functions are    executed in the    context    of the current shell;
      no new process is created to interpret them (contrast    this
      with the execution of    a shell    script).  When a function is
      executed, the    arguments to the function become the
      positional parameters    during its execution.  The special
      parameter #### is updated to reflect the    change.     Positional
      parameter 0 is unchanged.  All other aspects of the shell
      execution environment    are identical between a    function and
      its caller with the exception    that the DDDDEEEEBBBBUUUUGGGG trap (see the
      description of the ttttrrrraaaapppp builtin under    SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS
      below) is not    inherited.

      Variables local to the function may be declared with the
      llllooooccccaaaallll    builtin    command.  Ordinarily, variables    and their
      values are shared between the    function and its caller.

      If the builtin command rrrreeeettttuuuurrrrnnnn    is executed in a function, the
      function completes and execution resumes with    the next
      command after    the function call.  When a function completes,
      the values of    the positional parameters and the special
      parameter #### are restored to the values they had prior    to the
      function's execution.

      Function names and definitions may be    listed with the    ----ffff
      option to the    ddddeeeeccccllllaaaarrrreeee    or ttttyyyyppppeeeesssseeeetttt builtin commands.  The ----FFFF
      option to ddddeeeeccccllllaaaarrrreeee or ttttyyyyppppeeeesssseeeetttt will list the function names
      only.     Functions may be exported so that subshells
      automatically    have them defined with the ----ffff option to    the
      eeeexxxxppppoooorrrrtttt builtin.

      Functions may    be recursive.  No limit    is imposed on the
      number of recursive calls.

     AAAARRRRIIIITTTTHHHHMMMMEEEETTTTIIIICCCC    EEEEVVVVAAAALLLLUUUUAAAATTTTIIIIOOOONNNN



     PPPPaaaaggggeeee 33333333                         ((((pppprrrriiiinnnntttteeeedddd 3333////22225555////99999999))))






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      The shell allows arithmetic expressions to be    evaluated,
      under    certain    circumstances (see the lllleeeetttt builtin command and
      AAAArrrriiiitttthhhhmmmmeeeettttiiiicccc EEEExxxxppppaaaannnnssssiiiioooonnnn).  Evaluation is    done in    long integers
      with no check    for overflow, though division by 0 is trapped
      and flagged as an error.  The    following list of operators is
      grouped into levels of equal-precedence operators.  The
      levels are listed in order of    decreasing precedence.

      ---- ++++  unary minus and plus
      !!!! ~~~~  logical and bitwise negation
      ********   exponentiation
      **** //// %%%%
           multiplication, division, remainder
      ++++ ----  addition, subtraction
      <<<<<<<< >>>>>>>>
           left and    right bitwise shifts
      <<<<==== >>>>====    <<<< >>>>
           comparison
      ======== !!!!====
           equality    and inequality
      &&&&    bitwise AND
      ^^^^    bitwise exclusive OR
      ||||    bitwise OR
      &&&&&&&&   logical AND
      ||||||||   logical OR
      _e_x_p_r????_e_x_p_r::::_e_x_p_r
           conditional evaluation
      ==== ****==== ////==== %%%%==== ++++====    ----====
           assignment

      Shell    variables are allowed as operands; parameter expansion
      is performed before the expression is    evaluated. The value
      of a parameter is coerced to a long integer within an
      expression.  A shell variable    need not have its integer
      attribute turned on to be used in an expression.

      Constants with a leading 0 are interpreted as    octal numbers.
      A leading 0x or 0X denotes hexadecimal.  Otherwise, numbers
      take the form    [_b_a_s_e#]n, where    _b_a_s_e is    a decimal number
      between 2 and    64 representing    the arithmetic base, and _n is
      a number in that base.  If _b_a_s_e is omitted, then base    10 is
      used.     The digits greater than 9 are represented by the
      lowercase letters, the uppercase letters, _, and @, in that
      order.  If _b_a_s_e is less than or equal    to 36, lowercase and
      uppercase letters may    be used    interchangably to represent
      numbers between 10 and 35.

      Operators are    evaluated in order of precedence.  Sub-
      expressions in parentheses are evaluated first and may
      override the precedence rules    above.

     CCCCOOOONNNNDDDDIIIITTTTIIIIOOOONNNNAAAALLLL EEEEXXXXPPPPRRRREEEESSSSSSSSIIIIOOOONNNNSSSS



     PPPPaaaaggggeeee 33334444                         ((((pppprrrriiiinnnntttteeeedddd 3333////22225555////99999999))))






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      Conditional expressions are used by the [[[[[[[[ compound command
      and the tttteeeesssstttt and [[[[ builtin commands to test file attributes
      and perform string and arithmetic comparisons.  Expressions
      are formed from the following    unary or binary    primaries.  If
      any _f_i_l_e argument to one of the primaries is of the form
      /dev/fd/_n, then file descriptor _n is checked.

      ----aaaa _f_i_l_e
           True if _f_i_l_e exists.
      ----bbbb _f_i_l_e
           True if _f_i_l_e exists and is a block special file.
      ----cccc _f_i_l_e
           True if _f_i_l_e exists and is a character special file.
      ----dddd _f_i_l_e
           True if _f_i_l_e exists and is a directory.
      ----eeee _f_i_l_e
           True if _f_i_l_e exists.
      ----ffff _f_i_l_e
           True if _f_i_l_e exists and is a regular file.
      ----gggg _f_i_l_e
           True if _f_i_l_e exists and is set-group-id.
      ----hhhh _f_i_l_e
           True if _f_i_l_e exists and is a symbolic link.
      ----kkkk _f_i_l_e
           True if _f_i_l_e exists and its ``sticky'' bit is set.
      ----pppp _f_i_l_e
           True if _f_i_l_e exists and is a named pipe (FIFO).
      ----rrrr _f_i_l_e
           True if _f_i_l_e exists and is readable.
      ----ssss _f_i_l_e
           True if _f_i_l_e exists and has a size greater than zero.
      ----tttt _f_d
           True if file descriptor _f_d is open and refers to    a
           terminal.
      ----uuuu _f_i_l_e
           True if _f_i_l_e exists and its set-user-id bit is set.
      ----wwww _f_i_l_e
           True if _f_i_l_e exists and is writable.
      ----xxxx _f_i_l_e
           True if _f_i_l_e exists and is executable.
      ----OOOO _f_i_l_e
           True if _f_i_l_e exists and is owned    by the effective user
           id.
      ----GGGG _f_i_l_e
           True if _f_i_l_e exists and is owned    by the effective group
           id.
      ----LLLL _f_i_l_e
           True if _f_i_l_e exists and is a symbolic link.
      ----SSSS _f_i_l_e
           True if _f_i_l_e exists and is a socket.
      ----NNNN _f_i_l_e
           True if _f_i_l_e exists and has been    modified since it was



     Page 35                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           last read.
      _f_i_l_e_1    -nnnntttt _f_i_l_e_2
           True if _f_i_l_e_1 is    newer (according to modification date)
           than _f_i_l_e_2.
      _f_i_l_e_1    -ooootttt _f_i_l_e_2
           True if _f_i_l_e_1 is    older than _f_i_l_e_2.
      _f_i_l_e_1    ----eeeeffff _f_i_l_e_2
           True if _f_i_l_e_1 and _f_i_l_e_2 have the    same device and    inode
           numbers.
      ----oooo _o_p_t_n_a_m_e
           True if shell option _o_p_t_n_a_m_e is enabled.     See the list
           of options under    the description    of the ----oooo option to
           the sssseeeetttt builtin below.
      ----zzzz _s_t_r_i_n_g
           True if the length of _s_t_r_i_n_g is zero.
      ----nnnn _s_t_r_i_n_g
      _s_t_r_i_n_g
           True if the length of _s_t_r_i_n_g is non-zero.
      _s_t_r_i_n_g_1 ======== _s_t_r_i_n_g_2
           True if the strings are equal.  ==== may be    used in    place
           of ========.
      _s_t_r_i_n_g_1 !!!!==== _s_t_r_i_n_g_2
           True if the strings are not equal.
      _s_t_r_i_n_g_1 <<<< _s_t_r_i_n_g_2
           True if _s_t_r_i_n_g_1 sorts before _s_t_r_i_n_g_2 lexicographically
           in the current locale.
      _s_t_r_i_n_g_1 >>>> _s_t_r_i_n_g_2
           True if _s_t_r_i_n_g_1 sorts after _s_t_r_i_n_g_2 lexicographically
           in the current locale.
      _a_r_g_1 OOOOPPPP _a_r_g_2
           OOOOPPPP is one of ----eeeeqqqq, ----nnnneeee, ----lllltttt, ----lllleeee,    ----ggggtttt, or    ----ggggeeee.  These
           arithmetic binary operators return true if _a_r_g_1 is
           equal to, not equal to, less than, less than or equal
           to, greater than, or greater than or equal to _a_r_g_2,
           respectively.  _A_r_g_1 and _a_r_g_2 may    be positive or
           negative    integers.

     SSSSIIIIMMMMPPPPLLLLEEEE CCCCOOOOMMMMMMMMAAAANNNNDDDD EEEEXXXXPPPPAAAANNNNSSSSIIIIOOOONNNN
      When a simple    command    is executed, the shell performs    the
      following expansions,    assignments, and redirections, from
      left to right.

      1.   The words that the parser has marked as variable
           assignments (those preceding the    command    name) and
           redirections are    saved for later    processing.

      2.   The words that are not variable assignments or
           redirections are    expanded.  If any words    remain after
           expansion, the first word is taken to be    the name of
           the command and the remaining words are the arguments.

      3.   Redirections are    performed as described above under



     Page 36                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           RRRREEEEDDDDIIIIRRRREEEECCCCTTTTIIIIOOOONNNN.

      4.   The text    after the ==== in each variable assignment
           undergoes tilde expansion, parameter expansion, command
           substitution, arithmetic    expansion, and quote removal
           before being assigned to    the variable.

      If no    command    name results, the variable assignments affect
      the current shell environment.  Otherwise, the variables are
      added    to the environment of the executed command and do not
      affect the current shell environment.     If any    of the
      assignments attempts to assign a value to a readonly
      variable, an error occurs, and the command exits with    a
      non-zero status.

      If no    command    name results, redirections are performed, but
      do not affect    the current shell environment.    A redirection
      error    causes the command to exit with    a non-zero status.

      If there is a    command    name left after    expansion, execution
      proceeds as described    below.    Otherwise, the command exits.
      If one of the    expansions contained a command substitution,
      the exit status of the command is the    exit status of the
      last command substitution performed.    If there were no
      command substitutions, the command exits with    a status of
      zero.

     CCCCOOOOMMMMMMMMAAAANNNNDDDD EEEEXXXXEEEECCCCUUUUTTTTIIIIOOOONNNN
      After    a command has been split into words, if    it results in
      a simple command and an optional list    of arguments, the
      following actions are    taken.

      If the command name contains no slashes, the shell attempts
      to locate it.     If there exists a shell function by that
      name,    that function is invoked as described above in
      FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNNSSSS.  If the name does not match a function, the shell
      searches for it in the list of shell builtins.  If a match
      is found, that builtin is invoked.

      If the name is neither a shell function nor a    builtin, and
      contains no slashes, bbbbaaaasssshhhh searches each element of the PPPPAAAATTTTHHHH
      for a    directory containing an    executable file    by that    name.
      BBBBaaaasssshhhh uses a hash table to remember the full file names of
      executable files (see    hhhhaaaasssshhhh under SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS
      below).  A full search of the    directories in PPPPAAAATTTTHHHH is
      performed only if the    command    is not found in    the hash
      table.  If the search    is unsuccessful, the shell prints an
      error    message    and returns an exit status of 127.

      If the search    is successful, or if the command name contains
      one or more slashes, the shell executes the named program in
      a separate execution environment.  Argument 0    is set to the



     Page 37                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      name given, and the remaining    arguments to the command are
      set to the arguments given, if any.

      If this execution fails because the file is not in
      executable format, and the file is not a directory, it is
      assumed to be    a _s_h_e_l_l    _s_c_r_i_p_t,    a file containing shell
      commands.  A subshell    is spawned to execute it.  This
      subshell reinitializes itself, so that the effect is as if a
      new shell had    been invoked to    handle the script, with    the
      exception that the locations of commands remembered by the
      parent (see hhhhaaaasssshhhh below under SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS) are
      retained by the child.

      If the program is a file beginning with ####!!!!, the remainder of
      the first line specifies an interpreter for the program.
      The shell executes the specified interpreter on operating
      systems that do not handle this executable format
      themselves.  The arguments to    the interpreter    consist    of a
      single optional argument following the interpreter name on
      the first line of the    program, followed by the name of the
      program, followed by the command arguments, if any.

     CCCCOOOOMMMMMMMMAAAANNNNDDDD EEEEXXXXEEEECCCCUUUUTTTTIIIIOOOONNNN EEEENNNNVVVVIIIIRRRROOOONNNNMMMMEEEENNNNTTTT
      The shell has    an _e_x_e_c_u_t_i_o_n _e_n_v_i_r_o_n_m_e_n_t, which    consists of
      the following:


      +o    open files inherited by the shell at invocation,    as
           modified    by redirections    supplied to the    eeeexxxxeeeecccc builtin

      +o    the current working directory as    set by ccccdddd, ppppuuuusssshhhhdddd, or
           ppppooooppppdddd, or    inherited by the shell at invocation

      +o    the file    creation mode mask as set by uuuummmmaaaasssskkkk or
           inherited from the shell's parent

      +o    current traps set by ttttrrrraaaapppp

      +o    shell parameters    that are set by    variable assignment or
           with sssseeeetttt    or inherited from the shell's parent in    the
           environment

      +o    shell functions defined during execution    or inherited
           from the    shell's    parent in the environment

      +o    options enabled at invocation (either by    default    or
           with command-line arguments) or by sssseeeetttt

      +o    options enabled by sssshhhhoooopppptttt

      +o    shell aliases defined with aaaalllliiiiaaaassss




     Page 38                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      +o    various process IDs, including those of background
           jobs, the value of $$$$$$$$, and the value of $$$$PPPPPPPPIIIIDDDD

      When a simple    command    other than a builtin or    shell function
      is to    be executed, it    is invoked in a    separate execution
      environment that consists of the following.  Unless
      otherwise noted, the values are inherited from the shell.


      +o    the shell's open    files, plus any    modifications and
           additions specified by redirections to the command

      +o    the current working directory

      +o    the file    creation mode mask

      +o    shell variables marked for export, along    with variables
           exported    for the    command, passed    in the environment

      +o    traps caught by the shell are reset to the values the
           inherited from the shell's parent, and traps ignored by
           the shell are ignored

      A command invoked in this separate environment cannot    affect
      the shell's execution    environment.

      Command substitution and asynchronous    commands are invoked
      in a subshell    environment that is a duplicate    of the shell
      environment, except that traps caught    by the shell are reset
      to the values    that the shell inherited from its parent at
      invocation.  Builtin commands    that are invoked as part of a
      pipeline are also executed in    a subshell environment.
      Changes made to the subshell environment cannot affect the
      shell's execution environment.

     EEEENNNNVVVVIIIIRRRROOOONNNNMMMMEEEENNNNTTTT
      When a program is invoked it is given    an array of strings
      called the _e_n_v_i_r_o_n_m_e_n_t.  This    is a list of _n_a_m_e-_v_a_l_u_e    pairs,
      of the form _n_a_m_e=_v_a_l_u_e.

      The shell allows you to manipulate the environment in
      several ways.     On invocation,    the shell scans    its own
      environment and creates a parameter for each name found,
      automatically    marking    it for _e_x_p_o_r_t to child processes.
      Executed commands inherit the    environment.  The eeeexxxxppppoooorrrrtttt and
      ddddeeeeccccllllaaaarrrreeee ----xxxx commands allow parameters and functions to    be
      added    to and deleted from the    environment.  If the value of
      a parameter in the environment is modified, the new value
      becomes part of the environment, replacing the old.  The
      environment inherited    by any executed    command    consists of
      the shell's initial environment, whose values    may be
      modified in the shell, less any pairs    removed    by the uuuunnnnsssseeeetttt



     Page 39                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      command, plus    any additions via the eeeexxxxppppoooorrrrtttt and ddddeeeeccccllllaaaarrrreeee ----xxxx
      commands.

      The environment for any _s_i_m_p_l_e _c_o_m_m_a_n_d or function may be
      augmented temporarily    by prefixing it    with parameter
      assignments, as described above in PPPPAAAARRRRAAAAMMMMEEEETTTTEEEERRRRSSSS.  These
      assignment statements    affect only the    environment seen by
      that command.

      If the ----kkkk option is set (see the sssseeeetttt builtin command below),
      then _a_l_l parameter assignments are placed in the environment
      for a    command, not just those    that precede the command name.

      When bbbbaaaasssshhhh invokes an external    command, the variable ____    is set
      to the full file name    of the command and passed to that
      command in its environment.

     EEEEXXXXIIIITTTT SSSSTTTTAAAATTTTUUUUSSSS
      For the shell's purposes, a command which exits with a zero
      exit status has succeeded.  An exit status of    zero indicates
      success.  A non-zero exit status indicates failure.  When a
      command terminates on    a fatal    signal,    bbbbaaaasssshhhh uses the value of
      128+ssssiiiiggggnnnnaaaallll as    the exit status.

      If a command is not found, the child process created to
      execute it returns a status of 127.  If a command is found
      but is not executable, the return status is 126.

      If a command fails because of    an error during    expansion or
      redirection, the exit    status is greater than zero.

      Shell    builtin    commands return    a status of 0 (_t_r_u_e) if
      successful, and non-zero (_f_a_l_s_e) if an error occurs while
      they execute.    All builtins return an exit status of 2    to
      indicate incorrect usage.

      BBBBaaaasssshhhh itself returns the exit status of the last command
      executed, unless a syntax error occurs, in which case    it
      exits    with a non-zero    value.    See also the eeeexxxxiiiitttt builtin
      command below.

     SSSSIIIIGGGGNNNNAAAALLLLSSSS
      When bbbbaaaasssshhhh is interactive, in the absence of any traps, it
      ignores SSSSIIIIGGGGTTTTEEEERRRRMMMM (so that kkkkiiiillllllll    0000 does not kill    an interactive
      shell), and SSSSIIIIGGGGIIIINNNNTTTT is    caught and handled (so that the    wwwwaaaaiiiitttt
      builtin is interruptible).  In all cases, bbbbaaaasssshhhh ignores
      SSSSIIIIGGGGQQQQUUUUIIIITTTT.  If job control is in effect, bbbbaaaasssshhhh ignores SSSSIIIIGGGGTTTTTTTTIIIINNNN,
      SSSSIIIIGGGGTTTTTTTTOOOOUUUU, and SSSSIIIIGGGGTTTTSSSSTTTTPPPP.

      Synchronous jobs started by bbbbaaaasssshhhh have    signal handlers    set to
      the values inherited by the shell from its parent.  When job
      control is not in effect, asynchronous commands ignore



     Page 40                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      SSSSIIIIGGGGIIIINNNNTTTT and SSSSIIIIGGGGQQQQUUUUIIIITTTT as    well.  Commands    run as a result    of
      command substitution ignore the keyboard-generated job
      control signals SSSSIIIIGGGGTTTTTTTTIIIINNNN, SSSSIIIIGGGGTTTTTTTTOOOOUUUU, and    SSSSIIIIGGGGTTTTSSSSTTTTPPPP.

      The shell exits by default upon receipt of a SSSSIIIIGGGGHHHHUUUUPPPP.    Before
      exiting, it resends the SSSSIIIIGGGGHHHHUUUUPPPP to all    jobs, running or
      stopped.  Stopped jobs are sent SSSSIIIIGGGGCCCCOOOONNNNTTTT to ensure that they
      receive the SSSSIIIIGGGGHHHHUUUUPPPP.  To prevent the shell from sending the
      signal to a particular job, it should    be removed from    the
      jobs table with the ddddiiiissssoooowwwwnnnn builtin (see SSSSHHHHEEEELLLLLLLL    BBBBUUUUIIIILLLLTTTTIIIINNNN
      CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below) or marked to not receive SSSSIIIIGGGGHHHHUUUUPPPP using    ddddiiiissssoooowwwwnnnn
      ----hhhh.

      If the hhhhuuuuppppoooonnnneeeexxxxiiiitttt shell option    has been set with sssshhhhoooopppptttt, bbbbaaaasssshhhh
      sends    a SSSSIIIIGGGGHHHHUUUUPPPP to all    jobs when an interactive login shell
      exits.

      When bbbbaaaasssshhhh receives a signal for which    a trap has been    set
      while    waiting    for a command to complete, the trap will not
      be executed until the    command    completes.  When bbbbaaaasssshhhh is
      waiting for an asynchronous command via the wwwwaaaaiiiitttt builtin,
      the reception    of a signal for    which a    trap has been set will
      cause    the wwwwaaaaiiiitttt builtin to return immediately with an exit
      status greater than 128, immediately after which the trap is
      executed.

     JJJJOOOOBBBB CCCCOOOONNNNTTTTRRRROOOOLLLL
      _J_o_b _c_o_n_t_r_o_l refers to    the ability to selectively stop
      (_s_u_s_p_e_n_d) the    execution of processes and continue (_r_e_s_u_m_e)
      their    execution at a later point.  A user typically employs
      this facility    via an interactive interface supplied jointly
      by the system's terminal driver and bbbbaaaasssshhhh.

      The shell associates a _j_o_b with each pipeline.  It keeps a
      table    of currently executing jobs, which may be listed with
      the jjjjoooobbbbssss command.  When bbbbaaaasssshhhh starts a    job asynchronously (in
      the _b_a_c_k_g_r_o_u_n_d), it prints a line that looks like:

           [1] 25647

      indicating that this job is job number 1 and that the
      process ID of    the last process in the    pipeline associated
      with this job    is 25647.  All of the processes    in a single
      pipeline are members of the same job.     BBBBaaaasssshhhh uses the _j_o_b
      abstraction as the basis for job control.

      To facilitate    the implementation of the user interface to
      job control, the system maintains the    notion of a _c_u_r_r_e_n_t
      _t_e_r_m_i_n_a_l _p_r_o_c_e_s_s _g_r_o_u_p _I_D.  Members of this process group
      (processes whose process group ID is equal to    the current
      terminal process group ID) receive keyboard-generated
      signals such as SSSSIIIIGGGGIIIINNNNTTTT.  These processes are said to be in



     Page 41                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      the _f_o_r_e_g_r_o_u_n_d.  _B_a_c_k_g_r_o_u_n_d processes    are those whose
      process group    ID differs from    the terminal's;    such processes
      are immune to    keyboard-generated signals.  Only foreground
      processes are    allowed    to read    from or    write to the terminal.
      Background processes which attempt to    read from (write to)
      the terminal are sent    a SSSSIIIIGGGGTTTTTTTTIIIINNNN ((((SSSSIIIIGGGGTTTTTTTTOOOOUUUU)))) signal by the
      terminal driver, which, unless caught, suspends the process.

      If the operating system on which bbbbaaaasssshhhh    is running supports
      job control, bbbbaaaasssshhhh allows you to use it.  Typing the _s_u_s_p_e_n_d
      character (typically ^^^^ZZZZ, Control-Z) while a process is
      running causes that process to be stopped and    returns    you to
      bbbbaaaasssshhhh.     Typing    the _d_e_l_a_y_e_d _s_u_s_p_e_n_d character (typically ^^^^YYYY,
      Control-Y) causes the    process    to be stopped when it attempts
      to read input    from the terminal, and control to be returned
      to bbbbaaaasssshhhh.  The    user may then manipulate the state of this
      job, using the bbbbgggg command to continue    it in the background,
      the ffffgggg command to continue it    in the foreground, or the kkkkiiiillllllll
      command to kill it.  A ^^^^ZZZZ takes effect immediately, and has
      the additional side effect of    causing    pending    output and
      typeahead to be discarded.

      There    are a number of    ways to    refer to a job in the shell.
      The character    %%%% introduces a job name.  Job number _n may be
      referred to as %%%%nnnn.  A    job may    also be    referred to using a
      prefix of the    name used to start it, or using    a substring
      that appears in its command line.  For example, %%%%cccceeee refers
      to a stopped cccceeee job.    If a prefix matches more than one job,
      bbbbaaaasssshhhh reports an error.  Using    %%%%????cccceeee, on the other hand,
      refers to any    job containing the string cccceeee in    its command
      line.     If the    substring matches more than one    job, bbbbaaaasssshhhh
      reports an error.  The symbols %%%%%%%% and    %%%%++++ refer to the
      shell's notion of the    _c_u_r_r_e_n_t    _j_o_b, which is the last job
      stopped while    it was in the foreground or started in the
      background.  The _p_r_e_v_i_o_u_s _j_o_b    may be referenced using    %%%%----.
      In output pertaining to jobs (e.g., the output of the    jjjjoooobbbbssss
      command), the    current    job is always flagged with a ++++,    and
      the previous job with    a ----.

      Simply naming    a job can be used to bring it into the
      foreground:  %%%%1111 is a synonym for ````````ffffgggg    %%%%1111'''''''', bringing job 1
      from the background into the foreground.  Similarly, ````````%%%%1111
      &&&&'''''''' resumes job 1 in the background, equivalent to ````````bbbbgggg
      %%%%1111''''''''.

      The shell learns immediately whenever    a job changes state.
      Normally, bbbbaaaasssshhhh waits until it    is about to print a prompt
      before reporting changes in a    job's status so    as to not
      interrupt any    other output.  If the ----bbbb option    to the sssseeeetttt
      builtin command is enabled, bbbbaaaasssshhhh reports such    changes
      immediately.




     Page 42                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      If an    attempt    to exit    bbbbaaaasssshhhh is    made while jobs    are stopped,
      the shell prints a warning message.  The jjjjoooobbbbssss    command    may
      then be used to inspect their    status.     If a second attempt
      to exit is made without an intervening command, the shell
      does not print another warning, and the stopped jobs are
      terminated.

     PPPPRRRROOOOMMMMPPPPTTTTIIIINNNNGGGG
      When executing interactively,    bbbbaaaasssshhhh displays the primary
      prompt PPPPSSSS1111 when it is    ready to read a    command, and the
      secondary prompt PPPPSSSS2222 when it needs more input    to complete a
      command.  BBBBaaaasssshhhh allows    these prompt strings to    be customized
      by inserting a number    of backslash-escaped special
      characters that are decoded as follows:
           \\\\aaaa   an ASCII bell character (07)
           \\\\dddd   the    date in    "Weekday Month Date" format (e.g.,
            "Tue May 26")
           \\\\eeee   an ASCII escape character (033)
           \\\\hhhh   the    hostname up to the first `.'
           \\\\HHHH   the    hostname
           \\\\nnnn   newline
           \\\\rrrr   carriage return
           \\\\ssss   the    name of    the shell, the basename    of $$$$0000 (the
            portion following the final    slash)
           \\\\tttt   the    current    time in    24-hour    HH:MM:SS format
           \\\\TTTT   the    current    time in    12-hour    HH:MM:SS format
           \\\\@@@@   the    current    time in    12-hour    am/pm format
           \\\\uuuu   the    username of the    current    user
           \\\\vvvv   the    version    of bbbbaaaasssshhhh    (e.g., 2.00)
           \\\\VVVV   the    release    of bbbbaaaasssshhhh, version + patchlevel (e.g.,
            2.00.0)
           \\\\wwww   the    current    working    directory
           \\\\WWWW   the    basename of the    current    working    directory
           \\\\!!!!   the    history    number of this command
           \\\\####   the    command    number of this command
           \\\\$$$$   if the effective UID is 0, a ####, otherwise a    $$$$
           \\\\_n_n_n the    character corresponding    to the octal number
            _n_n_n
           \\\\\\\\   a backslash
           \\\\[[[[   begin a sequence of    non-printing characters, which
            could be used to embed a terminal control sequence
            into the prompt
           \\\\]]]]   end    a sequence of non-printing characters

      The command number and the history number are    usually
      different:  the history number of a command is its position
      in the history list, which may include commands restored
      from the history file    (see HHHHIIIISSSSTTTTOOOORRRRYYYY below), while the command
      number is the    position in the    sequence of commands executed
      during the current shell session.  After the string is
      decoded, it is expanded via parameter    expansion, command
      substitution,    arithmetic expansion, string expansion,    and



     Page 43                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      quote    removal, subject to the    value of the pppprrrroooommmmppppttttvvvvaaaarrrrssss    shell
      option (see the description of the sssshhhhoooopppptttt command under SSSSHHHHEEEELLLLLLLL
      BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below).

     RRRREEEEAAAADDDDLLLLIIIINNNNEEEE
      This is the library that handles reading input when using an
      interactive shell, unless the    --------nnnnooooeeeeddddiiiittttiiiinnnngggg option is given at
      shell    invocation.  By    default, the line editing commands are
      similar to those of emacs.  A    vi-style line editing
      interface is also available.    To turn    off line editing after
      the shell is running,    use the    ++++oooo eeeemmmmaaaaccccssss or ++++oooo vvvviiii options to
      the sssseeeetttt builtin (see SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below).

    RRRReeeeaaaaddddlllliiiinnnneeee NNNNoooottttaaaattttiiiioooonnnn
      In this section, the emacs-style notation is used to denote
      keystrokes.  Control keys are    denoted    by C-_k_e_y, e.g.,    C-n
      means    Control-N.  Similarly, _m_e_t_a keys are denoted by    M-_k_e_y,
      so M-x means Meta-X.    (On keyboards without a    _m_e_t_a key, M-_x
      means    ESC _x, i.e., press the Escape key then the _x key.
      This makes ESC the _m_e_t_a _p_r_e_f_i_x.  The combination M-C-_x means
      ESC-Control-_x, or press the Escape key then hold the Control
      key while pressing the _x key.)

      Readline commands may    be given numeric _a_r_g_u_m_e_n_t_s, which
      normally act as a repeat count.  Sometimes, however, it is
      the sign of the argument that    is significant.     Passing a
      negative argument to a command that acts in the forward
      direction (e.g., kkkkiiiillllllll----lllliiiinnnneeee) causes that command to act in a
      backward direction. Commands whose behavior with arguments
      deviates from    this are noted below.

      When a command is described as _k_i_l_l_i_n_g text, the text
      deleted is saved for possible    future retrieval (_y_a_n_k_i_n_g).
      The killed text is saved in a    _k_i_l_l _r_i_n_g.  Consecutive    kills
      cause    the text to be accumulated into    one unit, which    can be
      yanked all at    once. Commands which do    not kill text separate
      the chunks of    text on    the kill ring.

    RRRReeeeaaaaddddlllliiiinnnneeee IIIInnnniiiittttiiiiaaaalllliiiizzzzaaaattttiiiioooonnnn
      Readline is customized by putting commands in    an
      initialization file (the _i_n_p_u_t_r_c file).  The name of this
      file is taken    from the value of the IIIINNNNPPPPUUUUTTTTRRRRCCCC variable.     If
      that variable    is unset, the default is ~/._i_n_p_u_t_r_c.  When a
      program which    uses the readline library starts up, the
      initialization file is read, and the key bindings and
      variables are    set.  There are    only a few basic constructs
      allowed in the readline initialization file.    Blank lines
      are ignored.    Lines beginning    with a #### are comments.    Lines
      beginning with a $$$$ indicate conditional constructs.  Other
      lines    denote key bindings and    variable settings.

      The default key-bindings may be changed with an _i_n_p_u_t_r_c



     Page 44                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      file.     Other programs    that use this library may add their
      own commands and bindings.

      For example, placing

           M-Control-u: universal-argument
      or
           C-Meta-u: universal-argument
      into the _i_n_p_u_t_r_c would make M-C-u execute the    readline
      command _u_n_i_v_e_r_s_a_l-_a_r_g_u_m_e_n_t.

      The following    symbolic character names are recognized:
      _R_U_B_O_U_T, _D_E_L, _E_S_C, _L_F_D, _N_E_W_L_I_N_E, _R_E_T, _R_E_T_U_R_N, _S_P_C, _S_P_A_C_E, and
      _T_A_B.    In addition to command names, readline allows keys to
      be bound to a    string that is inserted    when the key is
      pressed (a _m_a_c_r_o).

    RRRReeeeaaaaddddlllliiiinnnneeee KKKKeeeeyyyy BBBBiiiinnnnddddiiiinnnnggggssss
      The syntax for controlling key bindings in the _i_n_p_u_t_r_c file
      is simple.  All that is required is the name of the command
      or the text of a macro and a key sequence to which it    should
      be bound. The    name may be specified in one of    two ways:  as
      a symbolic key name, possibly    with _M_e_t_a- or _C_o_n_t_r_o_l-
      prefixes, or as a key    sequence.  When    using the form
      kkkkeeeeyyyynnnnaaaammmmeeee:_f_u_n_c_t_i_o_n-_n_a_m_e    or _m_a_c_r_o, _k_e_y_n_a_m_e is the name of a key
      spelled out in English.  For example:

           Control-u: universal-argument
           Meta-Rubout: backward-kill-word
           Control-o: "> output"

      In the above example,    _C-_u is bound to    the function
      uuuunnnniiiivvvveeeerrrrssssaaaallll----aaaarrrrgggguuuummmmeeeennnntttt, _M-_D_E_L is bound to    the function
      bbbbaaaacccckkkkwwwwaaaarrrrdddd----kkkkiiiillllllll----wwwwoooorrrrdddd, and _C-_o is bound to run the macro
      expressed on the right hand side (that is, to    insert the
      text > _o_u_t_p_u_t    into the line).

      In the second    form, """"kkkkeeeeyyyysssseeeeqqqq"""":_f_u_n_c_t_i_o_n-_n_a_m_e or    _m_a_c_r_o, kkkkeeeeyyyysssseeeeqqqq
      differs from kkkkeeeeyyyynnnnaaaammmmeeee above in    that strings denoting an
      entire key sequence may be specified by placing the sequence
      within double    quotes.     Some GNU Emacs    style key escapes can
      be used, as in the following example.

           "\C-u": universal-argument
           "\C-x\C-r": re-read-init-file
           "\e[11~": "Function Key 1"

      In this example, _C-_u is again    bound to the function
      uuuunnnniiiivvvveeeerrrrssssaaaallll----aaaarrrrgggguuuummmmeeeennnntttt.  _C-_x _C-_r is bound    to the function
      rrrreeee----rrrreeeeaaaadddd----iiiinnnniiiitttt----ffffiiiilllleeee, and _E_S_C [ _1 _1 ~ is    bound to insert    the
      text FFFFuuuunnnnccccttttiiiioooonnnn    KKKKeeeeyyyy 1111.    The full set of    GNU Emacs style    escape
      sequences is



     Page 45                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           \\\\CCCC----  control prefix
           \\\\MMMM----  meta prefix
           \\\\eeee   an escape character
           \\\\\\\\   backslash
           \\\\""""   literal "
           \\\\''''   literal '

      In addition to the GNU Emacs style escape sequences, a
      second set of    backslash escapes is available:
           \\\\aaaa   alert (bell)
           \\\\bbbb   backspace
           \\\\dddd   delete
           \\\\ffff   form feed
           \\\\nnnn   newline
           \\\\rrrr   carriage return
           \\\\tttt   horizontal tab
           \\\\vvvv   vertical tab
           \\\\_n_n_n the    character whose    ASCII code is the octal    value
            _n_n_n    (one to    three digits)
           \\\\xxxx_n_n_n
            the    character whose    ASCII code is the hexadecimal
            value _n_n_n (one to three digits)

      When entering    the text of a macro, single or double quotes
      must be used to indicate a macro definition.    Unquoted text
      is assumed to    be a function name.  In    the macro body,    the
      backslash escapes described above are    expanded.  Backslash
      will quote any other character in the    macro text, including
      " and    '.

      BBBBaaaasssshhhh allows the current readline key bindings    to be
      displayed or modified    with the bbbbiiiinnnndddd builtin command.    The
      editing mode may be switched during interactive use by using
      the ----oooo option    to the sssseeeetttt builtin command (see    SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN
      CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below).

    RRRReeeeaaaaddddlllliiiinnnneeee VVVVaaaarrrriiiiaaaabbbblllleeeessss
      Readline has variables that can be used to further customize
      its behavior.     A variable may    be set in the _i_n_p_u_t_r_c file
      with a statement of the form

           sssseeeetttt _v_a_r_i_a_b_l_e-_n_a_m_e _v_a_l_u_e

      Except where noted, readline variables can take the values
      OOOOnnnn or    OOOOffffffff.  The variables and    their default values are:

      bbbbeeeellllllll----ssssttttyyyylllleeee ((((aaaauuuuddddiiiibbbblllleeee))))
           Controls    what happens when readline wants to ring the
           terminal    bell.  If set to nnnnoooonnnneeee, readline    never rings
           the bell.  If set to vvvviiiissssiiiibbbblllleeee, readline uses a visible
           bell if one is available.  If set to aaaauuuuddddiiiibbbblllleeee, readline
           attempts    to ring    the terminal's bell.



     Page 46                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      ccccoooommmmmmmmeeeennnntttt----bbbbeeeeggggiiiinnnn    ((((````````####''''''''))))
           The string that is inserted when    the rrrreeeeaaaaddddlllliiiinnnneeee
           iiiinnnnsssseeeerrrrtttt----ccccoooommmmmmmmeeeennnntttt command is executed.  This command is
           bound to    MMMM----#### in emacs mode and to #### in vi command mode.
      ccccoooommmmpppplllleeeettttiiiioooonnnn----iiiiggggnnnnoooorrrreeee----ccccaaaasssseeee ((((OOOOffffffff))))
           If set to OOOOnnnn, readline performs filename    matching and
           completion in a case-insensitive    fashion.
      ccccoooommmmpppplllleeeettttiiiioooonnnn----qqqquuuueeeerrrryyyy----iiiitttteeeemmmmssss ((((111100000000))))
           This determines when the    user is    queried    about viewing
           the number of possible completions generated by the
           ppppoooossssssssiiiibbbblllleeee----ccccoooommmmpppplllleeeettttiiiioooonnnnssss command.  It may be    set to any
           integer value greater than or equal to zero.  If    the
           number of possible completions is greater than or equal
           to the value of this variable, the user is asked
           whether or not he wishes    to view    them; otherwise    they
           are simply listed on the    terminal.
      ccccoooonnnnvvvveeeerrrrtttt----mmmmeeeettttaaaa ((((OOOOnnnn))))
           If set to OOOOnnnn, readline will convert characters with the
           eighth bit set to an ASCII key sequence by stripping
           the eighth bit and prepending an    escape character (in
           effect, using escape as the _m_e_t_a    _p_r_e_f_i_x).
      ddddiiiissssaaaabbbblllleeee----ccccoooommmmpppplllleeeettttiiiioooonnnn ((((OOOOffffffff))))
           If set to OOOOnnnn, readline will inhibit word    completion.
           Completion characters will be inserted into the line as
           if they had been    mapped to sssseeeellllffff----iiiinnnnsssseeeerrrrtttt.
      eeeeddddiiiittttiiiinnnngggg----mmmmooooddddeeee ((((eeeemmmmaaaaccccssss))))
           Controls    whether    readline begins    with a set of key
           bindings    similar    to _e_m_a_c_s or _v_i.     eeeeddddiiiittttiiiinnnngggg----mmmmooooddddeeee can be
           set to either eeeemmmmaaaaccccssss or vvvviiii.
      eeeennnnaaaabbbblllleeee----kkkkeeeeyyyyppppaaaadddd    ((((OOOOffffffff))))
           When set    to OOOOnnnn, readline    will try to enable the
           application keypad when it is called.  Some systems
           need this to enable the arrow keys.
      eeeexxxxppppaaaannnndddd----ttttiiiillllddddeeee ((((OOOOffffffff))))
           If set to oooonnnn, tilde expansion is    performed when
           readline    attempts word completion.
      hhhhoooorrrriiiizzzzoooonnnnttttaaaallll----ssssccccrrrroooollllllll----mmmmooooddddeeee ((((OOOOffffffff))))
           When set    to OOOOnnnn, makes readline use a single line    for
           display,    scrolling the input horizontally on a single
           screen line when    it becomes longer than the screen
           width rather than wrapping to a new line.
      iiiinnnnppppuuuutttt----mmmmeeeettttaaaa ((((OOOOffffffff))))
           If set to OOOOnnnn, readline will enable eight-bit input
           (that is, it will not strip the high bit    from the
           characters it reads), regardless    of what    the terminal
           claims it can support.  The name    mmmmeeeettttaaaa----ffffllllaaaagggg is a synonym
           for this    variable.
      iiiisssseeeeaaaarrrrcccchhhh----tttteeeerrrrmmmmiiiinnnnaaaattttoooorrrrssss ((((````````CCCC----[[[[CCCC----JJJJ''''''''))))
           The string of characters    that should terminate an
           incremental search without subsequently executing the
           character as a command.    If this    variable has not been
           given a value, the characters _E_S_C and _C-_J will



     Page 47                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           terminate an incremental    search.
      kkkkeeeeyyyymmmmaaaapppp ((((eeeemmmmaaaaccccssss))))
           Set the current readline    keymap.     The set of valid
           keymap names is _e_m_a_c_s, _e_m_a_c_s-_s_t_a_n_d_a_r_d, _e_m_a_c_s-_m_e_t_a,
           _e_m_a_c_s-_c_t_l_x, _v_i, _v_i-_c_o_m_m_a_n_d, and _v_i-_i_n_s_e_r_t.  _v_i is
           equivalent to _v_i-_c_o_m_m_a_n_d; _e_m_a_c_s is equivalent to
           _e_m_a_c_s-_s_t_a_n_d_a_r_d.    The default value is _e_m_a_c_s; the    value
           of eeeeddddiiiittttiiiinnnngggg----mmmmooooddddeeee also affects the    default    keymap.
      mmmmaaaarrrrkkkk----ddddiiiirrrreeeeccccttttoooorrrriiiieeeessss ((((OOOOnnnn))))
           If set to OOOOnnnn, completed directory names have a slash
           appended.
      mmmmaaaarrrrkkkk----mmmmooooddddiiiiffffiiiieeeedddd----lllliiiinnnneeeessss ((((OOOOffffffff))))
           If set to OOOOnnnn, history lines that    have been modified are
           displayed with a    preceding asterisk (****).
      oooouuuuttttppppuuuutttt----mmmmeeeettttaaaa ((((OOOOffffffff))))
           If set to OOOOnnnn, readline will display characters with the
           eighth bit set directly rather than as a    meta-prefixed
           escape sequence.
      pppprrrriiiinnnntttt----ccccoooommmmpppplllleeeettttiiiioooonnnnssss----hhhhoooorrrriiiizzzzoooonnnnttttaaaallllllllyyyy ((((OOOOffffffff))))
           If set to OOOOnnnn, readline will display completions with
           matches sorted horizontally in alphabetical order,
           rather than down    the screen.
      sssshhhhoooowwww----aaaallllllll----iiiiffff----aaaammmmbbbbiiiigggguuuuoooouuuussss    ((((OOOOffffffff))))
           This alters the default behavior    of the completion
           functions.  If set to oooonnnn, words which have more than
           one possible completion cause the matches to be listed
           immediately instead of ringing the bell.
      vvvviiiissssiiiibbbblllleeee----ssssttttaaaattttssss    ((((OOOOffffffff))))
           If set to OOOOnnnn, a character denoting a file's type    as
           reported    by _s_t_a_t(2) is appended to the filename when
           listing possible    completions.

    RRRReeeeaaaaddddlllliiiinnnneeee CCCCoooonnnnddddiiiittttiiiioooonnnnaaaallll CCCCoooonnnnssssttttrrrruuuuccccttttssss
      Readline implements a    facility similar in spirit to the
      conditional compilation features of the C preprocessor which
      allows key bindings and variable settings to be performed as
      the result of    tests.    There are four parser directives used.

      $$$$iiiiffff  The $$$$iiiiffff construct allows    bindings to be made based on
           the editing mode, the terminal being used, or the
           application using readline.  The    text of    the test
           extends to the end of the line; no characters are
           required    to isolate it.

           mmmmooooddddeeee The    mmmmooooddddeeee==== form of the $$$$iiiiffff directive    is used    to
            test whether readline is in    emacs or vi mode.
            This may be    used in    conjunction with the sssseeeetttt
            kkkkeeeeyyyymmmmaaaapppp command, for    instance, to set bindings in
            the    _e_m_a_c_s-_s_t_a_n_d_a_r_d and _e_m_a_c_s-_c_t_l_x keymaps only if
            readline is    starting out in    emacs mode.

           tttteeeerrrrmmmm The    tttteeeerrrrmmmm==== form may be used to include terminal-



     Page 48                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



            specific key bindings, perhaps to bind the key
            sequences output by    the terminal's function    keys.
            The    word on    the right side of the ====    is tested
            against the    both full name of the terminal and the
            portion of the terminal name before    the first ----.
            This allows    _s_u_n to match both _s_u_n and _s_u_n-_c_m_d, for
            instance.

           aaaapppppppplllliiiiccccaaaattttiiiioooonnnn
            The    aaaapppppppplllliiiiccccaaaattttiiiioooonnnn construct is used to include
            application-specific settings.  Each program using
            the    readline library sets the _a_p_p_l_i_c_a_t_i_o_n _n_a_m_e,
            and    an initialization file can test    for a
            particular value.  This could be used to bind key
            sequences to functions useful for a    specific
            program.  For instance, the    following command adds
            a key sequence that    quotes the current or previous
            word in Bash:

            $$$$iiiiffff    Bash
            # Quote the    current    or previous word
            "\C-xq": "\eb\"\ef\""
            $$$$eeeennnnddddiiiiffff

      $$$$eeeennnnddddiiiiffff
           This command, as    seen in    the previous example,
           terminates an $$$$iiiiffff command.

      $$$$eeeellllsssseeee
           Commands    in this    branch of the $$$$iiiiffff directive are
           executed    if the test fails.

      $$$$iiiinnnncccclllluuuuddddeeee
           This directive takes a single filename as an argument
           and reads commands and bindings from that file.    For
           example,    the following directive    would read
           /_e_t_c/_i_n_p_u_t_r_c:

           $$$$iiiinnnncccclllluuuuddddeeee     /_e_t_c/_i_n_p_u_t_r_c

    SSSSeeeeaaaarrrrcccchhhhiiiinnnngggg
      Readline provides commands for searching through the command
      history (see HHHHIIIISSSSTTTTOOOORRRRYYYY below) for lines    containing a specified
      string.  There are two search    modes:    _i_n_c_r_e_m_e_n_t_a_l and    _n_o_n-
      _i_n_c_r_e_m_e_n_t_a_l.

      Incremental searches begin before the    user has finished
      typing the search string.  As    each character of the search
      string is typed, readline displays the next entry from the
      history matching the string typed so far.  An    incremental
      search requires only as many characters as needed to find
      the desired history entry.  The characters present in    the



     Page 49                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      value    of the _i_s_e_a_r_c_h-_t_e_r_m_i_n_a_t_o_r_s variable are    used to
      terminate an incremental search.  If that variable has not
      been assigned    a value    the Escape and Control-J characters
      will terminate an incremental    search.     Control-G will    abort
      an incremental search    and restore the    original line.    When
      the search is    terminated, the    history    entry containing the
      search string    becomes    the current line.  To find other
      matching entries in the history list,    type Control-S or
      Control-R as appropriate.  This will search backward or
      forward in the history for the next entry matching the
      search string    typed so far.  Any other key sequence bound to
      a readline command will terminate the    search and execute
      that command.     For instance, a _n_e_w_l_i_n_e will terminate    the
      search and accept the    line, thereby executing    the command
      from the history list.

      Non-incremental searches read    the entire search string
      before starting to search for    matching history lines.     The
      search string    may be typed by    the user or be part of the
      contents of the current line.

    RRRReeeeaaaaddddlllliiiinnnneeee CCCCoooommmmmmmmaaaannnndddd NNNNaaaammmmeeeessss
      The following    is a list of the names of the commands and the
      default key sequences    to which they are bound.  Command
      names    without    an accompanying    key sequence are unbound by
      default.

    CCCCoooommmmmmmmaaaannnnddddssss ffffoooorrrr MMMMoooovvvviiiinnnngggg
      bbbbeeeeggggiiiinnnnnnnniiiinnnngggg----ooooffff----lllliiiinnnneeee ((((CCCC----aaaa))))
           Move to the start of the    current    line.
      eeeennnndddd----ooooffff----lllliiiinnnneeee ((((CCCC----eeee))))
           Move to the end of the line.
      ffffoooorrrrwwwwaaaarrrrdddd----cccchhhhaaaarrrr ((((CCCC----ffff))))
           Move forward a character.
      bbbbaaaacccckkkkwwwwaaaarrrrdddd----cccchhhhaaaarrrr    ((((CCCC----bbbb))))
           Move back a character.
      ffffoooorrrrwwwwaaaarrrrdddd----wwwwoooorrrrdddd ((((MMMM----ffff))))
           Move forward to the end of the next word.  Words    are
           composed    of alphanumeric    characters (letters and
           digits).
      bbbbaaaacccckkkkwwwwaaaarrrrdddd----wwwwoooorrrrdddd    ((((MMMM----bbbb))))
           Move back to the    start of this, or the previous,    word.
           Words are composed of alphanumeric characters (letters
           and digits).
      cccclllleeeeaaaarrrr----ssssccccrrrreeeeeeeennnn ((((CCCC----llll))))
           Clear the screen    leaving    the current line at the    top of
           the screen.  With an argument, refresh the current line
           without clearing    the screen.
      rrrreeeeddddrrrraaaawwww----ccccuuuurrrrrrrreeeennnntttt----lllliiiinnnneeee
           Refresh the current line.

    CCCCoooommmmmmmmaaaannnnddddssss ffffoooorrrr MMMMaaaannnniiiippppuuuullllaaaattttiiiinnnngggg tttthhhheeee HHHHiiiissssttttoooorrrryyyy



     PPPPaaaaggggeeee 55550000                         ((((pppprrrriiiinnnntttteeeedddd 3333////22225555////99999999))))






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      aaaacccccccceeeepppptttt----lllliiiinnnneeee ((((NNNNeeeewwwwlllliiiinnnneeee,,,,    RRRReeeettttuuuurrrrnnnn))))
           Accept the line regardless of where the cursor is.  If
           this line is non-empty, add it to the history list
           according to the    state of the HHHHIIIISSSSTTTTCCCCOOOONNNNTTTTRRRROOOOLLLL variable.  If
           the line    is a modified history line, then restore the
           history line to its original state.
      pppprrrreeeevvvviiiioooouuuussss----hhhhiiiissssttttoooorrrryyyy ((((CCCC----pppp))))
           Fetch the previous command from the history list,
           moving back in the list.
      nnnneeeexxxxtttt----hhhhiiiissssttttoooorrrryyyy ((((CCCC----nnnn))))
           Fetch the next command from the history list, moving
           forward in the list.
      bbbbeeeeggggiiiinnnnnnnniiiinnnngggg----ooooffff----hhhhiiiissssttttoooorrrryyyy ((((MMMM----<<<<))))
           Move to the first line in the history.
      eeeennnndddd----ooooffff----hhhhiiiissssttttoooorrrryyyy ((((MMMM---->>>>))))
           Move to the end of the input history, i.e., the line
           currently being entered.
      rrrreeeevvvveeeerrrrsssseeee----sssseeeeaaaarrrrcccchhhh----hhhhiiiissssttttoooorrrryyyy ((((CCCC----rrrr))))
           Search backward starting    at the current line and    moving
           `up' through the    history    as necessary.  This is an
           incremental search.
      ffffoooorrrrwwwwaaaarrrrdddd----sssseeeeaaaarrrrcccchhhh----hhhhiiiissssttttoooorrrryyyy ((((CCCC----ssss))))
           Search forward starting at the current line and moving
           `down' through the history as necessary.     This is an
           incremental search.
      nnnnoooonnnn----iiiinnnnccccrrrreeeemmmmeeeennnnttttaaaallll----rrrreeeevvvveeeerrrrsssseeee----sssseeeeaaaarrrrcccchhhh----hhhhiiiissssttttoooorrrryyyy ((((MMMM----pppp))))
           Search backward through the history starting at the
           current line using a non-incremental search for a
           string supplied by the user.
      nnnnoooonnnn----iiiinnnnccccrrrreeeemmmmeeeennnnttttaaaallll----ffffoooorrrrwwwwaaaarrrrdddd----sssseeeeaaaarrrrcccchhhh----hhhhiiiissssttttoooorrrryyyy ((((MMMM----nnnn))))
           Search forward through the history using    a non-
           incremental search for a    string supplied    by the user.
      hhhhiiiissssttttoooorrrryyyy----sssseeeeaaaarrrrcccchhhh----ffffoooorrrrwwwwaaaarrrrdddd
           Search forward through the history for the string of
           characters between the start of the current line    and
           the current cursor position (the    _p_o_i_n_t).     This is a
           non-incremental search.
      hhhhiiiissssttttoooorrrryyyy----sssseeeeaaaarrrrcccchhhh----bbbbaaaacccckkkkwwwwaaaarrrrdddd
           Search backward through the history for the string of
           characters between the start of the current line    and
           the point.  This    is a non-incremental search.
      yyyyaaaannnnkkkk----nnnntttthhhh----aaaarrrrgggg ((((MMMM----CCCC----yyyy))))
           Insert the first    argument to the    previous command
           (usually    the second word    on the previous    line) at point
           (the current cursor position).  With an argument    _n,
           insert the _nth word from    the previous command (the
           words in    the previous command begin with    word 0).  A
           negative    argument inserts the _nth word from the end of
           the previous command.
      yyyyaaaannnnkkkk----llllaaaasssstttt----aaaarrrrgggg    ((((MMMM----....,,,, MMMM----____))))
           Insert the last argument    to the previous    command    (the
           last word of the    previous history entry).  With an



     Page 51                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           argument, behave    exactly    like yyyyaaaannnnkkkk----nnnntttthhhh----aaaarrrrgggg.  Successive
           calls to    yyyyaaaannnnkkkk----llllaaaasssstttt----aaaarrrrgggg move back    through    the history
           list, inserting the last    argument of each line in turn.
      sssshhhheeeellllllll----eeeexxxxppppaaaannnndddd----lllliiiinnnneeee ((((MMMM----CCCC----eeee))))
           Expand the line as the shell does.  This    performs alias
           and history expansion as    well as    all of the shell word
           expansions.  See    HHHHIIIISSSSTTTTOOOORRRRYYYY    EEEEXXXXPPPPAAAANNNNSSSSIIIIOOOONNNN below    for a
           description of history expansion.
      hhhhiiiissssttttoooorrrryyyy----eeeexxxxppppaaaannnndddd----lllliiiinnnneeee ((((MMMM----^^^^))))
           Perform history expansion on the    current    line.  See
           HHHHIIIISSSSTTTTOOOORRRRYYYY EEEEXXXXPPPPAAAANNNNSSSSIIIIOOOONNNN below for a description of history
           expansion.
      mmmmaaaaggggiiiicccc----ssssppppaaaacccceeee
           Perform history expansion on the    current    line and
           insert a    space.    See HHHHIIIISSSSTTTTOOOORRRRYYYY EEEEXXXXPPPPAAAANNNNSSSSIIIIOOOONNNN below for    a
           description of history expansion.
      aaaalllliiiiaaaassss----eeeexxxxppppaaaannnndddd----lllliiiinnnneeee
           Perform alias expansion on the current line.  See
           AAAALLLLIIIIAAAASSSSEEEESSSS above for a description of alias    expansion.
      hhhhiiiissssttttoooorrrryyyy----aaaannnndddd----aaaalllliiiiaaaassss----eeeexxxxppppaaaannnndddd----lllliiiinnnneeee
           Perform history and alias expansion on the current
           line.
      iiiinnnnsssseeeerrrrtttt----llllaaaasssstttt----aaaarrrrgggguuuummmmeeeennnntttt ((((MMMM----....,,,, MMMM----____))))
           A synonym for yyyyaaaannnnkkkk----llllaaaasssstttt----aaaarrrrgggg.
      ooooppppeeeerrrraaaatttteeee----aaaannnndddd----ggggeeeetttt----nnnneeeexxxxtttt ((((CCCC----oooo))))
           Accept the current line for execution and fetch the
           next line relative to the current line from the history
           for editing.  Any argument is ignored.

    CCCCoooommmmmmmmaaaannnnddddssss ffffoooorrrr CCCChhhhaaaannnnggggiiiinnnngggg TTTTeeeexxxxtttt
      ddddeeeelllleeeetttteeee----cccchhhhaaaarrrr ((((CCCC----dddd))))
           Delete the character under the cursor.  If point    is at
           the beginning of    the line, there    are no characters in
           the line, and the last character    typed was not bound to
           ddddeeeelllleeeetttteeee----cccchhhhaaaarrrr, then return    EEEEOOOOFFFF.
      bbbbaaaacccckkkkwwwwaaaarrrrdddd----ddddeeeelllleeeetttteeee----cccchhhhaaaarrrr ((((RRRRuuuubbbboooouuuutttt))))
           Delete the character behind the cursor.    When given a
           numeric argument, save the deleted text on the kill
           ring.
      ffffoooorrrrwwwwaaaarrrrdddd----bbbbaaaacccckkkkwwwwaaaarrrrdddd----ddddeeeelllleeeetttteeee----cccchhhhaaaarrrr
           Delete the character under the cursor, unless the
           cursor is at the    end of the line, in which case the
           character behind    the cursor is deleted.    By default,
           this is not bound to a key.
      qqqquuuuooootttteeeedddd----iiiinnnnsssseeeerrrrtttt    ((((CCCC----qqqq,,,, CCCC----vvvv))))
           Add the next character typed to the line    verbatim.
           This is how to insert characters    like CCCC----qqqq, for example.
      ttttaaaabbbb----iiiinnnnsssseeeerrrrtttt ((((CCCC----vvvv TTTTAAAABBBB))))
           Insert a    tab character.
      sssseeeellllffff----iiiinnnnsssseeeerrrrtttt ((((aaaa,,,, bbbb,,,, AAAA,,,,    1111,,,, !!!!,,,, ............))))
           Insert the character typed.
      ttttrrrraaaannnnssssppppoooosssseeee----cccchhhhaaaarrrrssss ((((CCCC----tttt))))



     Page 52                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           Drag the    character before point forward over the
           character at point.  Point moves    forward    as well.  If
           point is    at the end of the line,    then transpose the two
           characters before point.     Negative arguments don't
           work.
      ttttrrrraaaannnnssssppppoooosssseeee----wwwwoooorrrrddddssss ((((MMMM----tttt))))
           Drag the    word behind the    cursor past the    word in    front
           of the cursor moving the    cursor over that word as well.
      uuuuppppccccaaaasssseeee----wwwwoooorrrrdddd ((((MMMM----uuuu))))
           Uppercase the current (or following) word.  With    a
           negative    argument, uppercase the    previous word, but do
           not move    point.
      ddddoooowwwwnnnnccccaaaasssseeee----wwwwoooorrrrdddd    ((((MMMM----llll))))
           Lowercase the current (or following) word.  With    a
           negative    argument, lowercase the    previous word, but do
           not move    point.
      ccccaaaappppiiiittttaaaalllliiiizzzzeeee----wwwwoooorrrrdddd ((((MMMM----cccc))))
           Capitalize the current (or following) word.  With a
           negative    argument, capitalize the previous word,    but do
           not move    point.

    KKKKiiiilllllllliiiinnnngggg    aaaannnndddd YYYYaaaannnnkkkkiiiinnnngggg
      kkkkiiiillllllll----lllliiiinnnneeee ((((CCCC----kkkk))))
           Kill the    text from the current cursor position to the
           end of the line.
      bbbbaaaacccckkkkwwwwaaaarrrrdddd----kkkkiiiillllllll----lllliiiinnnneeee ((((CCCC----xxxx RRRRuuuubbbboooouuuutttt))))
           Kill backward to    the beginning of the line.
      uuuunnnniiiixxxx----lllliiiinnnneeee----ddddiiiissssccccaaaarrrrdddd ((((CCCC----uuuu))))
           Kill backward from point    to the beginning of the    line.
           The killed text is saved    on the kill-ring.

      kkkkiiiillllllll----wwwwhhhhoooolllleeee----lllliiiinnnneeee
           Kill all    characters on the current line,    no matter
           where the cursor    is.
      kkkkiiiillllllll----wwwwoooorrrrdddd ((((MMMM----dddd))))
           Kill from the cursor to the end of the current word, or
           if between words, to the    end of the next    word.  Word
           boundaries are the same as those    used by    ffffoooorrrrwwwwaaaarrrrdddd----wwwwoooorrrrdddd.
      bbbbaaaacccckkkkwwwwaaaarrrrdddd----kkkkiiiillllllll----wwwwoooorrrrdddd ((((MMMM----RRRRuuuubbbboooouuuutttt))))
           Kill the    word behind the    cursor.     Word boundaries are
           the same    as those used by bbbbaaaacccckkkkwwwwaaaarrrrdddd----wwwwoooorrrrdddd.
      uuuunnnniiiixxxx----wwwwoooorrrrdddd----rrrruuuubbbboooouuuutttt ((((CCCC----wwww))))
           Kill the    word behind the    cursor,    using white space as a
           word boundary.  The word    boundaries are different from
           bbbbaaaacccckkkkwwwwaaaarrrrdddd----kkkkiiiillllllll----wwwwoooorrrrdddd.
      ddddeeeelllleeeetttteeee----hhhhoooorrrriiiizzzzoooonnnnttttaaaallll----ssssppppaaaacccceeee ((((MMMM----\\\\))))
           Delete all spaces and tabs around point.
      kkkkiiiillllllll----rrrreeeeggggiiiioooonnnn
           Kill the    text between the point and _m_a_r_k    (saved cursor
           position).  This    text is    referred to as the _r_e_g_i_o_n.
      ccccooooppppyyyy----rrrreeeeggggiiiioooonnnn----aaaassss----kkkkiiiillllllll
           Copy the    text in    the region to the kill buffer.



     Page 53                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      ccccooooppppyyyy----bbbbaaaacccckkkkwwwwaaaarrrrdddd----wwwwoooorrrrdddd
           Copy the    word before point to the kill buffer.  The
           word boundaries are the same as bbbbaaaacccckkkkwwwwaaaarrrrdddd----wwwwoooorrrrdddd.
      ccccooooppppyyyy----ffffoooorrrrwwwwaaaarrrrdddd----wwwwoooorrrrdddd
           Copy the    word following point to    the kill buffer.  The
           word boundaries are the same as ffffoooorrrrwwwwaaaarrrrdddd----wwwwoooorrrrdddd.
      yyyyaaaannnnkkkk ((((CCCC----yyyy))))
           Yank the    top of the kill    ring into the buffer at    the
           cursor.
      yyyyaaaannnnkkkk----ppppoooopppp ((((MMMM----yyyy))))
           Rotate the kill ring, and yank the new top.  Only works
           following yyyyaaaannnnkkkk or yyyyaaaannnnkkkk----ppppoooopppp.

    NNNNuuuummmmeeeerrrriiiicccc    AAAArrrrgggguuuummmmeeeennnnttttssss
      ddddiiiiggggiiiitttt----aaaarrrrgggguuuummmmeeeennnntttt ((((MMMM----0000,,,, MMMM----1111,,,, ............,,,, MMMM--------))))
           Add this    digit to the argument already accumulating, or
           start a new argument.  M-- starts a negative argument.
      uuuunnnniiiivvvveeeerrrrssssaaaallll----aaaarrrrgggguuuummmmeeeennnntttt
           This is another way to specify an argument.  If this
           command is followed by one or more digits, optionally
           with a leading minus sign, those    digits define the
           argument.  If the command is followed by    digits,
           executing uuuunnnniiiivvvveeeerrrrssssaaaallll----aaaarrrrgggguuuummmmeeeennnntttt again ends the numeric
           argument, but is    otherwise ignored.  As a special case,
           if this command is immediately followed by a character
           that is neither a digit or minus    sign, the argument
           count for the next command is multiplied    by four.  The
           argument    count is initially one,    so executing this
           function    the first time makes the argument count    four,
           a second    time makes the argument    count sixteen, and so
           on.

    CCCCoooommmmpppplllleeeettttiiiinnnngggg
      ccccoooommmmpppplllleeeetttteeee ((((TTTTAAAABBBB))))
           Attempt to perform completion on    the text before    point.
           BBBBaaaasssshhhh attempts completion    treating the text as a
           variable    (if the    text begins with $$$$), username (if the
           text begins with    ~~~~), hostname (if the text begins with
           @@@@), or command (including aliases and functions)    in
           turn.  If none of these produces    a match, filename
           completion is attempted.
      ppppoooossssssssiiiibbbblllleeee----ccccoooommmmpppplllleeeettttiiiioooonnnnssss ((((MMMM----????))))
           List the    possible completions of    the text before    point.
      iiiinnnnsssseeeerrrrtttt----ccccoooommmmpppplllleeeettttiiiioooonnnnssss ((((MMMM----****))))
           Insert all completions of the text before point that
           would have been generated by ppppoooossssssssiiiibbbblllleeee----ccccoooommmmpppplllleeeettttiiiioooonnnnssss.
      mmmmeeeennnnuuuu----ccccoooommmmpppplllleeeetttteeee
           Similar to ccccoooommmmpppplllleeeetttteeee, but    replaces the word to be
           completed with a    single match from the list of possible
           completions.  Repeated execution    of mmmmeeeennnnuuuu----ccccoooommmmpppplllleeeetttteeee steps
           through the list    of possible completions, inserting
           each match in turn.  At the end of the list of



     Page 54                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           completions, the    bell is    rung and the original text is
           restored.  An argument of _n moves _n positions forward
           in the list of matches; a negative argument may be used
           to move backward    through    the list.  This    command    is
           intended    to be bound to TTTTAAAABBBB, but    is unbound by default.
      ddddeeeelllleeeetttteeee----cccchhhhaaaarrrr----oooorrrr----lllliiiisssstttt
           Deletes the character under the cursor if not at    the
           beginning or end    of the line (like ddddeeeelllleeeetttteeee----cccchhhhaaaarrrr).     If at
           the end of the line, behaves identically    to ppppoooossssssssiiiibbbblllleeee----
           ccccoooommmmpppplllleeeettttiiiioooonnnnssss.  This command is unbound by    default.
      ccccoooommmmpppplllleeeetttteeee----ffffiiiilllleeeennnnaaaammmmeeee ((((MMMM----////))))
           Attempt filename    completion on the text before point.
      ppppoooossssssssiiiibbbblllleeee----ffffiiiilllleeeennnnaaaammmmeeee----ccccoooommmmpppplllleeeettttiiiioooonnnnssss    ((((CCCC----xxxx ////))))
           List the    possible completions of    the text before    point,
           treating    it as a    filename.
      ccccoooommmmpppplllleeeetttteeee----uuuusssseeeerrrrnnnnaaaammmmeeee ((((MMMM----~~~~))))
           Attempt completion on the text before point, treating
           it as a username.
      ppppoooossssssssiiiibbbblllleeee----uuuusssseeeerrrrnnnnaaaammmmeeee----ccccoooommmmpppplllleeeettttiiiioooonnnnssss    ((((CCCC----xxxx ~~~~))))
           List the    possible completions of    the text before    point,
           treating    it as a    username.
      ccccoooommmmpppplllleeeetttteeee----vvvvaaaarrrriiiiaaaabbbblllleeee ((((MMMM----$$$$))))
           Attempt completion on the text before point, treating
           it as a shell variable.
      ppppoooossssssssiiiibbbblllleeee----vvvvaaaarrrriiiiaaaabbbblllleeee----ccccoooommmmpppplllleeeettttiiiioooonnnnssss    ((((CCCC----xxxx $$$$))))
           List the    possible completions of    the text before    point,
           treating    it as a    shell variable.
      ccccoooommmmpppplllleeeetttteeee----hhhhoooossssttttnnnnaaaammmmeeee ((((MMMM----@@@@))))
           Attempt completion on the text before point, treating
           it as a hostname.
      ppppoooossssssssiiiibbbblllleeee----hhhhoooossssttttnnnnaaaammmmeeee----ccccoooommmmpppplllleeeettttiiiioooonnnnssss    ((((CCCC----xxxx @@@@))))
           List the    possible completions of    the text before    point,
           treating    it as a    hostname.
      ccccoooommmmpppplllleeeetttteeee----ccccoooommmmmmmmaaaannnndddd ((((MMMM----!!!!))))
           Attempt completion on the text before point, treating
           it as a command name.  Command completion attempts to
           match the text against aliases, reserved    words, shell
           functions, shell    builtins, and finally executable
           filenames, in that order.
      ppppoooossssssssiiiibbbblllleeee----ccccoooommmmmmmmaaaannnndddd----ccccoooommmmpppplllleeeettttiiiioooonnnnssss ((((CCCC----xxxx !!!!))))
           List the    possible completions of    the text before    point,
           treating    it as a    command    name.
      ddddyyyynnnnaaaammmmiiiicccc----ccccoooommmmpppplllleeeetttteeee----hhhhiiiissssttttoooorrrryyyy ((((MMMM----TTTTAAAABBBB))))
           Attempt completion on the text before point, comparing
           the text    against    lines from the history list for
           possible    completion matches.
      ccccoooommmmpppplllleeeetttteeee----iiiinnnnttttoooo----bbbbrrrraaaacccceeeessss ((((MMMM----{{{{))))
           Perform filename    completion and return the list of
           possible    completions enclosed within braces so the list
           is available to the shell (see BBBBrrrraaaacccceeee EEEExxxxppppaaaannnnssssiiiioooonnnn above).

    KKKKeeeeyyyybbbbooooaaaarrrrdddd MMMMaaaaccccrrrroooossss



     PPPPaaaaggggeeee 55555555                         ((((pppprrrriiiinnnntttteeeedddd 3333////22225555////99999999))))






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      ssssttttaaaarrrrtttt----kkkkbbbbdddd----mmmmaaaaccccrrrroooo ((((CCCC----xxxx (((())))
           Begin saving the    characters typed into the current
           keyboard    macro.
      eeeennnndddd----kkkkbbbbdddd----mmmmaaaaccccrrrroooo    ((((CCCC----xxxx ))))))))
           Stop saving the characters typed    into the current
           keyboard    macro and store    the definition.
      ccccaaaallllllll----llllaaaasssstttt----kkkkbbbbdddd----mmmmaaaaccccrrrroooo ((((CCCC----xxxx eeee))))
           Re-execute the last keyboard macro defined, by making
           the characters in the macro appear as if    typed at the
           keyboard.

    MMMMiiiisssscccceeeellllllllaaaannnneeeeoooouuuussss
      rrrreeee----rrrreeeeaaaadddd----iiiinnnniiiitttt----ffffiiiilllleeee ((((CCCC----xxxx CCCC----rrrr))))
           Read in the contents of the _i_n_p_u_t_r_c file, and
           incorporate any bindings    or variable assignments    found
           there.
      aaaabbbboooorrrrtttt    ((((CCCC----gggg))))
           Abort the current editing command and ring the
           terminal's bell (subject    to the setting of bbbbeeeellllllll----ssssttttyyyylllleeee).
      ddddoooo----uuuuppppppppeeeerrrrccccaaaasssseeee----vvvveeeerrrrssssiiiioooonnnn ((((MMMM----aaaa,,,, MMMM----bbbb,,,, MMMM----_x,,,, ............))))
           If the metafied character _x is lowercase, run the
           command that is bound to    the corresponding uppercase
           character.
      pppprrrreeeeffffiiiixxxx----mmmmeeeettttaaaa ((((EEEESSSSCCCC))))
           Metafy the next character typed.     EEEESSSSCCCC ffff is equivalent
           to MMMMeeeettttaaaa----ffff.
      uuuunnnnddddoooo ((((CCCC----____,,,, CCCC----xxxx CCCC----uuuu))))
           Incremental undo, separately remembered for each    line.
      rrrreeeevvvveeeerrrrtttt----lllliiiinnnneeee ((((MMMM----rrrr))))
           Undo all    changes    made to    this line.  This is like
           executing the uuuunnnnddddoooo command enough times to return the
           line to its initial state.
      ttttiiiillllddddeeee----eeeexxxxppppaaaannnndddd ((((MMMM----&&&&))))
           Perform tilde expansion on the current word.
      sssseeeetttt----mmmmaaaarrrrkkkk ((((CCCC----@@@@,,,, MMMM----<<<<ssssppppaaaacccceeee>>>>))))
           Set the mark to the current point.  If a    numeric
           argument    is supplied, the mark is set to    that position.
      eeeexxxxcccchhhhaaaannnnggggeeee----ppppooooiiiinnnntttt----aaaannnndddd----mmmmaaaarrrrkkkk ((((CCCC----xxxx CCCC----xxxx))))
           Swap the    point with the mark.  The current cursor
           position    is set to the saved position, and the old
           cursor position is saved    as the mark.
      cccchhhhaaaarrrraaaacccctttteeeerrrr----sssseeeeaaaarrrrcccchhhh ((((CCCC----]]]]))))
           A character is read and point is    moved to the next
           occurrence of that character.  A    negative count
           searches    for previous occurrences.
      cccchhhhaaaarrrraaaacccctttteeeerrrr----sssseeeeaaaarrrrcccchhhh----bbbbaaaacccckkkkwwwwaaaarrrrdddd ((((MMMM----CCCC----]]]]))))
           A character is read and point is    moved to the previous
           occurrence of that character.  A    negative count
           searches    for subsequent occurrences.
      iiiinnnnsssseeeerrrrtttt----ccccoooommmmmmmmeeeennnntttt ((((MMMM----####))))
           The value of the    rrrreeeeaaaaddddlllliiiinnnneeee ccccoooommmmmmmmeeeennnntttt----bbbbeeeeggggiiiinnnn variable    is
           inserted    at the beginning of the    current    line, and the



     Page 56                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           line is accepted    as if a    newline    had been typed.     This
           makes the current line a    shell comment.
      gggglllloooobbbb----eeeexxxxppppaaaannnndddd----wwwwoooorrrrdddd ((((CCCC----xxxx    ****))))
           The word    before point is    treated    as a pattern for
           pathname    expansion, and the list    of matching file names
           is inserted, replacing the word.
      gggglllloooobbbb----lllliiiisssstttt----eeeexxxxppppaaaannnnssssiiiioooonnnnssss ((((CCCC----xxxx gggg))))
           The list    of expansions that would have been generated
           by gggglllloooobbbb----eeeexxxxppppaaaannnndddd----wwwwoooorrrrdddd is displayed, and the line is
           redrawn.
      dddduuuummmmpppp----ffffuuuunnnnccccttttiiiioooonnnnssss
           Print all of the    functions and their key    bindings to
           the readline output stream.  If a numeric argument is
           supplied, the output is formatted in such a way that it
           can be made part    of an _i_n_p_u_t_r_c file.
      dddduuuummmmpppp----vvvvaaaarrrriiiiaaaabbbblllleeeessss
           Print all of the    settable readline variables and    their
           values to the readline output stream.  If a numeric
           argument    is supplied, the output    is formatted in    such a
           way that    it can be made part of an _i_n_p_u_t_r_c file.
      dddduuuummmmpppp----mmmmaaaaccccrrrroooossss
           Print all of the    readline key sequences bound to    macros
           and the strings they ouput.  If a numeric argument is
           supplied, the output is formatted in such a way that it
           can be made part    of an _i_n_p_u_t_r_c file.
      ddddiiiissssppppllllaaaayyyy----sssshhhheeeellllllll----vvvveeeerrrrssssiiiioooonnnn    ((((CCCC----xxxx CCCC----vvvv))))
           Display version information about the current instance
           of bbbbaaaasssshhhh.

     HHHHIIIISSSSTTTTOOOORRRRYYYY
      When the ----oooo hhhhiiiissssttttoooorrrryyyy option to    the sssseeeetttt    builtin    is enabled,
      the shell provides access to the _c_o_m_m_a_n_d _h_i_s_t_o_r_y, the    list
      of commands previously typed.     The text of the last HHHHIIIISSSSTTTTSSSSIIIIZZZZEEEE
      commands (default 500) is saved in a history list.  The
      shell    stores each command in the history list    prior to
      parameter and    variable expansion (see    EEEEXXXXPPPPAAAANNNNSSSSIIIIOOOONNNN above) but
      after    history    expansion is performed,    subject    to the values
      of the shell variables HHHHIIIISSSSTTTTIIIIGGGGNNNNOOOORRRREEEE and    HHHHIIIISSSSTTTTCCCCOOOONNNNTTTTRRRROOOOLLLL.  On
      startup, the history is initialized from the file named by
      the variable HHHHIIIISSSSTTTTFFFFIIIILLLLEEEE    (default ~/._b_a_s_h__h_i_s_t_o_r_y).  HHHHIIIISSSSTTTTFFFFIIIILLLLEEEE
      is truncated,    if necessary, to contain no more than
      HHHHIIIISSSSTTTTFFFFIIIILLLLEEEESSSSIIIIZZZZEEEE lines.  When an interactive shell exits,    the
      last HHHHIIIISSSSTTTTSSSSIIIIZZZZEEEE    lines are copied from the history list to
      HHHHIIIISSSSTTTTFFFFIIIILLLLEEEE.  If    the hhhhiiiissssttttaaaappppppppeeeennnndddd shell option is enabled (see
      the description of sssshhhhoooopppptttt under SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS
      below), the lines are    appended to the    history    file,
      otherwise the    history    file is    overwritten.  If HHHHIIIISSSSTTTTFFFFIIIILLLLEEEE is
      unset, or if the history file    is unwritable, the history is
      not saved.  After saving the history,    the history file is
      truncated to contain no more than HHHHIIIISSSSTTTTFFFFIIIILLLLEEEESSSSIIIIZZZZEEEE lines.     If
      HHHHIIIISSSSTTTTFFFFIIIILLLLEEEESSSSIIIIZZZZEEEE is not set, no truncation is performed.




     Page 57                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      The builtin command ffffcccc (see SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below)
      may be used to list or edit and re-execute a portion of the
      history list.     The hhhhiiiissssttttoooorrrryyyy builtin can be used to display or
      modify the history list and manipulate the history file.
      When using the command-line editing, search commands are
      available in each editing mode that provide access to    the
      history list.

      The shell allows control over    which commands are saved on
      the history list.  The HHHHIIIISSSSTTTTCCCCOOOONNNNTTTTRRRROOOOLLLL and HHHHIIIISSSSTTTTIIIIGGGGNNNNOOOORRRREEEE variables
      may be set to    cause the shell    to save    only a subset of the
      commands entered.  The ccccmmmmddddhhhhiiiisssstttt shell option, if enabled,
      causes the shell to attempt to save each line    of a multi-
      line command in the same history entry, adding semicolons
      where    necessary to preserve syntactic    correctness.  The
      lllliiiitttthhhhiiiisssstttt shell    option causes the shell    to save    the command
      with embedded    newlines instead of semicolons.     See the
      description of the sssshhhhoooopppptttt builtin below under SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN
      CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS for information on setting and unsetting shell
      options.

     HHHHIIIISSSSTTTTOOOORRRRYYYY EEEEXXXXPPPPAAAANNNNSSSSIIIIOOOONNNN
      The shell supports a history expansion feature that is
      similar to the history expansion in ccccsssshhhh....  This section
      describes what syntax    features are available.     This feature
      is enabled by    default    for interactive    shells,    and can    be
      disabled using the ++++HHHH    option to the sssseeeetttt builtin command (see
      SSSSHHHHEEEELLLLLLLL    BBBBUUUUIIIILLLLTTTTIIIINNNN    CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below).  Non-interactive shells do
      not perform history expansion    by default.

      History expansions introduce words from the history list
      into the input stream, making    it easy    to repeat commands,
      insert the arguments to a previous command into the current
      input    line, or fix errors in previous    commands quickly.

      History expansion is performed immediately after a complete
      line is read,    before the shell breaks    it into    words.    It
      takes    place in two parts.  The first is to determine which
      line from the    history    list to    use during substitution.  The
      second is to select portions of that line for    inclusion into
      the current one.  The    line selected from the history is the
      _e_v_e_n_t, and the portions of that line that are    acted upon are
      _w_o_r_d_s.  Various _m_o_d_i_f_i_e_r_s are    available to manipulate    the
      selected words.  The line is broken into words in the    same
      fashion as when reading input, so that several
      _m_e_t_a_c_h_a_r_a_c_t_e_r-separated words    surrounded by quotes are
      considered one word.    History    expansions are introduced by
      the appearance of the    history    expansion character, which is
      !!!! by default.     Only backslash    (\\\\) and    single quotes can
      quote    the history expansion character.

      Several shell    options    settable with the sssshhhhoooopppptttt    builtin    may be



     Page 58                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      used to tailor the behavior of history expansion.  If    the
      hhhhiiiissssttttvvvveeeerrrriiiiffffyyyy shell option is enabled (see the description of
      the sssshhhhoooopppptttt builtin), and rrrreeeeaaaaddddlllliiiinnnneeee is being used, history
      substitutions    are not    immediately passed to the shell
      parser.  Instead, the    expanded line is reloaded into the
      rrrreeeeaaaaddddlllliiiinnnneeee editing buffer for further modification.  If
      rrrreeeeaaaaddddlllliiiinnnneeee is being used, and the hhhhiiiissssttttrrrreeeeeeeeddddiiiitttt shell option is
      enabled, a failed history substitution will be reloaded into
      the rrrreeeeaaaaddddlllliiiinnnneeee editing buffer for correction.  The ----pppp option
      to the hhhhiiiissssttttoooorrrryyyy builtin command may be    used to    see what a
      history expansion will do before using it.  The ----ssss option to
      the hhhhiiiissssttttoooorrrryyyy builtin may be used to add commands to the end
      of the history list without actually executing them, so that
      they are available for subsequent recall.

      The shell allows control of the various characters used by
      the history expansion    mechanism (see the description of
      hhhhiiiissssttttcccchhhhaaaarrrrssss above under    SSSShhhheeeellllllll VVVVaaaarrrriiiiaaaabbbblllleeeessss).

    EEEEvvvveeeennnntttt DDDDeeeessssiiiiggggnnnnaaaattttoooorrrrssss
      An event designator is a reference to    a command line entry
      in the history list.

      !!!!    Start a history substitution, except when followed by a
           bbbbllllaaaannnnkkkk, newline, = or (.
      !!!!_n   Refer to    command    line _n.
      !!!!----_n  Refer to    the current command line minus _n.
      !!!!!!!!   Refer to    the previous command.  This is a synonym for
           `!-1'.
      !!!!_s_t_r_i_n_g
           Refer to    the most recent    command    starting with _s_t_r_i_n_g.
      !!!!????_s_t_r_i_n_g[[[[????]]]]
           Refer to    the most recent    command    containing _s_t_r_i_n_g.
           The trailing ???? may be omitted if    _s_t_r_i_n_g is followed
           immediately by a    newline.
       _s_t_r_i_n_g_1 _s_t_r_i_n_g_2
      ^^^^    Qui^^^^ck subst^^^^itution.  Repeat the last command, replacing
           _s_t_r_i_n_g_1 with _s_t_r_i_n_g_2.  Equivalent to
           ``!!:s/_s_t_r_i_n_g_1/_s_t_r_i_n_g_2/'' (see MMMMooooddddiiiiffffiiiieeeerrrrssss    below).
      !!!!####   The entire command line typed so    far.

    WWWWoooorrrrdddd DDDDeeeessssiiiiggggnnnnaaaattttoooorrrrssss
      Word designators are used to select desired words from the
      event.  A :::: separates    the event specification    from the word
      designator.  It may be omitted if the    word designator    begins
      with a ^^^^, $$$$, ****, ----, or    %%%%.  Words are numbered from the
      beginning of the line, with the first    word being denoted by
      0 (zero).  Words are inserted    into the current line
      separated by single spaces.

      0000 ((((zzzzeeeerrrroooo))))
           The zeroth word.     For the shell,    this is    the command



     Page 59                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           word.
      _n    The _nth word.
      ^^^^    The first argument.  That is, word 1.
      $$$$    The last    argument.
      %%%%    The word    matched    by the most recent `?_s_t_r_i_n_g?' search.
      _x----_y  A range of words; `-_y' abbreviates `0-_y'.
      ****    All of the words    but the    zeroth.     This is a synonym for
           `_1-$'.  It is not an error to use **** if there is just
           one word    in the event; the empty    string is returned in
           that case.
      xxxx****   Abbreviates _x-$.
      xxxx----   Abbreviates _x-$ like xxxx****,    but omits the last word.

      If a word designator is supplied without an event
      specification, the previous command is used as the event.

    MMMMooooddddiiiiffffiiiieeeerrrrssss
      After    the optional word designator, there may    appear a
      sequence of one or more of the following modifiers, each
      preceded by a    `:'.

      hhhh    Remove a    trailing file name component, leaving only the
           head.
      tttt    Remove all leading file name components,    leaving    the
           tail.
      rrrr    Remove a    trailing suffix    of the form ._x_x_x, leaving the
           basename.
      eeee    Remove all but the trailing suffix.
      pppp    Print the new command but do not    execute    it.
      qqqq    Quote the substituted words, escaping further
           substitutions.
      xxxx    Quote the substituted words as with qqqq, but break    into
           words at    bbbbllllaaaannnnkkkkssss and newlines.
      ssss////_o_l_d////_n_e_w////
           Substitute _n_e_w for the first occurrence of _o_l_d in the
           event line.  Any    delimiter can be used in place of /.
           The final delimiter is optional if it is    the last
           character of the    event line.  The delimiter may be
           quoted in _o_l_d and _n_e_w with a single backslash.  If &
           appears in _n_e_w, it is replaced by _o_l_d.  A single
           backslash will quote the    &.  If _o_l_d is null, it is set
           to the last _o_l_d substituted, or,    if no previous history
           substitutions took place, the last _s_t_r_i_n_g in a
           !!!!????_s_t_r_i_n_g[[[[????]]]] search.
      &&&&    Repeat the previous substitution.
      gggg    Cause changes to    be applied over    the entire event line.
           This is used in conjunction with    `::::ssss' (e.g.,
           `::::ggggssss////_o_l_d////_n_e_w////') or `::::&&&&'.     If used with `::::ssss', any
           delimiter can be    used in    place of /, and    the final
           delimiter is optional if    it is the last character of
           the event line.




     Page 60                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



     SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS
      Unless otherwise noted, each builtin command documented in
      this section as accepting options preceded by    ---- accepts --------
      to signify the end of    the options.

      :::: [_a_r_g_u_m_e_n_t_s]
           No effect; the command does nothing beyond expanding
           _a_r_g_u_m_e_n_t_s and performing    any specified redirections.  A
           zero exit code is returned.

       ....  _f_i_l_e_n_a_m_e [_a_r_g_u_m_e_n_t_s]
      ssssoooouuuurrrrcccceeee _f_i_l_e_n_a_m_e [_a_r_g_u_m_e_n_t_s]
           Read and    execute    commands from _f_i_l_e_n_a_m_e in the current
           shell environment and return the    exit status of the
           last command executed from _f_i_l_e_n_a_m_e.  If    _f_i_l_e_n_a_m_e does
           not contain a slash, file names in PPPPAAAATTTTHHHH are used    to
           find the    directory containing _f_i_l_e_n_a_m_e.    The file
           searched    for in PPPPAAAATTTTHHHH need not be    executable.  The
           current directory is searched if    no file    is found in
           PPPPAAAATTTTHHHH.  If the ssssoooouuuurrrrcccceeeeppppaaaatttthhhh    option to the sssshhhhoooopppptttt builtin
           command is turned off, the PPPPAAAATTTTHHHH is not searched.     If
           any _a_r_g_u_m_e_n_t_s are supplied, they    become the positional
           parameters when _f_i_l_e_n_a_m_e    is executed.  Otherwise    the
           positional parameters are unchanged.  The return    status
           is the status of    the last command exited    within the
           script (0 if no commands    are executed), and false if
           _f_i_l_e_n_a_m_e    is not found or    cannot be read.

      aaaalllliiiiaaaassss    [----pppp] [_n_a_m_e[=_v_a_l_u_e] ...]
           AAAAlllliiiiaaaassss with no arguments or with the ----pppp option prints
           the list    of aliases in the form aaaalllliiiiaaaassss _n_a_m_e=_v_a_l_u_e    on
           standard    output.     When arguments    are supplied, an alias
           is defined for each _n_a_m_e    whose _v_a_l_u_e is given.  A
           trailing    space in  _v_a_l_u_e    causes the next    word to    be
           checked for alias substitution when the alias is
           expanded.  For each _n_a_m_e    in the argument    list for which
           no _v_a_l_u_e    is supplied, the name and value    of the alias
           is printed.  AAAAlllliiiiaaaassss returns true unless a    _n_a_m_e is    given
           for which no alias has been defined.

      bbbbgggg [_j_o_b_s_p_e_c]
           Resume the suspended job    _j_o_b_s_p_e_c    in the background, as
           if it had been started with &&&&.  If _j_o_b_s_p_e_c is not
           present,    the shell's notion of the _c_u_r_r_e_n_t _j_o_b is used.
           bbbbgggg _j_o_b_s_p_e_c returns 0 unless run when job    control    is
           disabled    or, when run with job control enabled, if
           _j_o_b_s_p_e_c was not found or    started    without    job control.

      bbbbiiiinnnndddd [----mmmm _k_e_y_m_a_p] [----llllppppssssvvvvPPPPSSSSVVVV]
      bbbbiiiinnnndddd [----mmmm _k_e_y_m_a_p] [----qqqq _f_u_n_c_t_i_o_n] [----uuuu _f_u_n_c_t_i_o_n] [----rrrr _k_e_y_s_e_q]
      bbbbiiiinnnndddd [----mmmm _k_e_y_m_a_p] ----ffff _f_i_l_e_n_a_m_e
      bbbbiiiinnnndddd [----mmmm _k_e_y_m_a_p] _k_e_y_s_e_q:_f_u_n_c_t_i_o_n-_n_a_m_e
           Display current rrrreeeeaaaaddddlllliiiinnnneeee    key and    function bindings, or


     Page 61                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           bind a key sequence to a    rrrreeeeaaaaddddlllliiiinnnneeee function or macro.
           The binding syntax accepted is identical    to that    of
           ._i_n_p_u_t_r_c, but each binding must be passed as a separate
           argument; e.g., '"\C-x\C-r": re-read-init-file'.
           Options,    if supplied, have the following    meanings:
           ----mmmm _k_e_y_m_a_p
            Use    _k_e_y_m_a_p as the keymap to    be affected by the
            subsequent bindings.  Acceptable _k_e_y_m_a_p names are
            _e_m_a_c_s, _e_m_a_c_s-_s_t_a_n_d_a_r_d, _e_m_a_c_s-_m_e_t_a, _e_m_a_c_s-_c_t_l_x, _v_i,
            _v_i-_c_o_m_m_a_n_d,    and _v_i-_i_n_s_e_r_t.    _v_i is equivalent to
            _v_i-_c_o_m_m_a_n_d;    _e_m_a_c_s is equivalent to _e_m_a_c_s-_s_t_a_n_d_a_r_d.
           ----llll   List the names of all rrrreeeeaaaaddddlllliiiinnnneeee functions.
           ----pppp   Display rrrreeeeaaaaddddlllliiiinnnneeee function names and    bindings in
            such a way that they can be    re-read.
           ----PPPP   List current rrrreeeeaaaaddddlllliiiinnnneeee function names and bindings.
           ----vvvv   Display rrrreeeeaaaaddddlllliiiinnnneeee variable names and    values in such
            a way that they can    be re-read.
           ----VVVV   List current rrrreeeeaaaaddddlllliiiinnnneeee variable names and values.
           ----ssss   Display rrrreeeeaaaaddddlllliiiinnnneeee key sequences bound to macros and
            the    strings    they output in such a way that they
            can    be re-read.
           ----SSSS   Display rrrreeeeaaaaddddlllliiiinnnneeee key sequences bound to macros and
            the    strings    they output.
           ----ffff _f_i_l_e_n_a_m_e
            Read key bindings from _f_i_l_e_n_a_m_e.
           ----qqqq _f_u_n_c_t_i_o_n
            Query about    which keys invoke the named _f_u_n_c_t_i_o_n.
           ----uuuu _f_u_n_c_t_i_o_n
            Unbind all keys bound to the named _f_u_n_c_t_i_o_n.
           ----rrrr _k_e_y_s_e_q
            Remove any current binding for _k_e_y_s_e_q.

           The return value    is 0 unless an unrecognized option is
           given or    an error occurred.

      bbbbrrrreeeeaaaakkkk    [_n]
           Exit from within    a ffffoooorrrr, wwwwhhhhiiiilllleeee, uuuunnnnttttiiiillll, or    sssseeeelllleeeecccctttt loop.
           If _n is specified, break    _n levels.  _n must be _> 1.  If
           _n is greater than the number of enclosing loops,    all
           enclosing loops are exited.  The    return value is    0
           unless the shell    is not executing a loop    when bbbbrrrreeeeaaaakkkk is
           executed.

      bbbbuuuuiiiillllttttiiiinnnn _s_h_e_l_l-_b_u_i_l_t_i_n    [_a_r_g_u_m_e_n_t_s]
           Execute the specified shell builtin, passing it
           _a_r_g_u_m_e_n_t_s, and return its exit status.  This is useful
           when defining a function    whose name is the same as a
           shell builtin, retaining    the functionality of the
           builtin within the function.  The ccccdddd builtin is
           commonly    redefined this way.  The return    status is
           false if    _s_h_e_l_l-_b_u_i_l_t_i_n is not a shell builtin command.




     Page 62                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      ccccdddd [----LLLLPPPP] [_d_i_r]
           Change the current directory to _d_i_r.  The variable HHHHOOOOMMMMEEEE
           is the default _d_i_r.  The    variable CCCCDDDDPPPPAAAATTTTHHHH    defines    the
           search path for the directory containing    _d_i_r.
           Alternative directory names in CCCCDDDDPPPPAAAATTTTHHHH are separated by
           a colon (:).  A null directory name in CCCCDDDDPPPPAAAATTTTHHHH is    the
           same as the current directory, i.e., ``....''.  If _d_i_r
           begins with a slash (/),    then CCCCDDDDPPPPAAAATTTTHHHH is not used. The
           ----PPPP option says to use the physical directory structure
           instead of following symbolic links (see    also the ----PPPP
           option to the sssseeeetttt builtin command); the ----LLLL option
           forces symbolic links to    be followed.  An argument of ----
           is equivalent to    $$$$OOOOLLLLDDDDPPPPWWWWDDDD.  The return value is true if
           the directory was successfully changed; false
           otherwise.

      ccccoooommmmmmmmaaaannnndddd [----ppppVVVVvvvv] _c_o_m_m_a_n_d [_a_r_g ...]
           Run _c_o_m_m_a_n_d with    _a_r_g_s suppressing the normal shell
           function    lookup.    Only builtin commands or commands
           found in    the PPPPAAAATTTTHHHH are executed.    If the ----pppp option is
           given, the search for _c_o_m_m_a_n_d is    performed using    a
           default value for PPPPAAAATTTTHHHH that is guaranteed to find all
           of the standard utilities.  If either the ----VVVV or ----vvvv
           option is supplied, a description of _c_o_m_m_a_n_d is
           printed.     The ----vvvv    option causes a    single word indicating
           the command or file name    used to    invoke _c_o_m_m_a_n_d to be
           displayed; the ----VVVV option    produces a more    verbose
           description.  If    the ----VVVV or ----vvvv option is supplied, the
           exit status is 0    if _c_o_m_m_a_n_d was found, and 1 if not.
           If neither option is supplied and an error occurred or
           _c_o_m_m_a_n_d cannot be found,    the exit status    is 127.
           Otherwise, the exit status of the ccccoooommmmmmmmaaaannnndddd builtin is
           the exit    status of _c_o_m_m_a_n_d.

      ccccoooonnnnttttiiiinnnnuuuueeee [_n]
           Resume the next iteration of the    enclosing ffffoooorrrr, wwwwhhhhiiiilllleeee,
           uuuunnnnttttiiiillll, or sssseeeelllleeeecccctttt    loop.  If _n is specified, resume at
           the _nth enclosing loop.    _n must be _> 1.    If _n is
           greater than the    number of enclosing loops, the last
           enclosing loop (the ``top-level'' loop) is resumed.
           The return value    is 0 unless the    shell is not executing
           a loop when ccccoooonnnnttttiiiinnnnuuuueeee is executed.

      ddddeeeeccccllllaaaarrrreeee [----aaaaffffFFFFiiiirrrrxxxx] [----pppp] [_n_a_m_e[=_v_a_l_u_e]]
      ttttyyyyppppeeeesssseeeetttt [----aaaaffffFFFFiiiirrrrxxxx] [----pppp] [_n_a_m_e[=_v_a_l_u_e]]
           Declare variables and/or    give them attributes.  If no
           _n_a_m_es are given then display the    values of variables.
           The ----pppp option will display the attributes and values of
           each _n_a_m_e.  When    ----pppp is used, additional options are
           ignored.     The ----FFFF    option inhibits    the display of
           function    definitions; only the function name and
           attributes are printed.    The ----FFFF option implies ----ffff.  The



     Page 63                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           following options can be    used to    restrict output    to
           variables with the specified attribute or to give
           variables attributes:
           ----aaaa   Each _n_a_m_e is an array variable (see    AAAArrrrrrrraaaayyyyssss above).
           ----ffff   Use    function names only.
           ----iiii   The    variable is treated as an integer; arithmetic
            evaluation (see AAAARRRRIIIITTTTHHHHMMMMEEEETTTTIIIICCCC EEEEVVVVAAAALLLLUUUUAAAATTTTIIIIOOOONNNN )))) is
            performed when the variable    is assigned a value.
           ----rrrr   Make _n_a_m_es readonly.  These    names cannot then be
            assigned values by subsequent assignment
            statements or unset.
           ----xxxx   Mark _n_a_m_es for export to subsequent    commands via
            the    environment.

           Using `+' instead of `-'    turns off the attribute
           instead,    with the exception that    ++++aaaa may not be used to
           destroy an array    variable.  When    used in    a function,
           makes each _n_a_m_e local, as with the llllooooccccaaaallll    command.  The
           return value is 0 unless    an invalid option is
           encountered, an attempt is made to define a function
           using "-f foo=bar", an attempt is made to assign    a
           value to    a readonly variable, an    attempt    is made    to
           assign a    value to an array variable without using the
           compound    assignment syntax (see AAAArrrrrrrraaaayyyyssss above), one of
           the _n_a_m_e_s is not    a valid    shell variable name, an
           attempt is made to turn off readonly status for a
           readonly    variable, an attempt is    made to    turn off array
           status for an array variable, or    an attempt is made to
           display a non-existent function with -f.

      ddddiiiirrrrssss [[[[----ccccllllppppvvvv]]]] [[[[++++_n]]]] [[[[----_n]]]]
           Without options,    displays the list of currently
           remembered directories.    The default display is on a
           single line with    directory names    separated by spaces.
           Directories are added to    the list with the ppppuuuusssshhhhdddd
           command;    the ppppooooppppdddd command removes entries from the
           list.
           ++++_n   Displays the _nth entry counting from the left of
            the    list shown by ddddiiiirrrrssss when    invoked    without
            options, starting with zero.
           ----_n   Displays the _nth entry counting from the right of
            the    list shown by ddddiiiirrrrssss when    invoked    without
            options, starting with zero.
           ----cccc   Clears the directory stack by deleting all of the
            entries.
           ----llll   Produces a longer listing; the default listing
            format uses    a tilde    to denote the home directory.
           ----pppp   Print the directory    stack with one entry per line.
           ----vvvv   Print the directory    stack with one entry per line,
            prefixing each entry with its index    in the stack.

           The return value    is 0 unless an invalid option is



     Page 64                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           supplied    or _n indexes beyond the    end of the directory
           stack.

      ddddiiiissssoooowwwwnnnn [----aaaarrrr] [----hhhh] [_j_o_b_s_p_e_c ...]
           Without options,    each _j_o_b_s_p_e_c is    removed    from the table
           of active jobs.    If the ----hhhh option is given, each
           _j_o_b_s_p_e_c is not removed from the table, but is marked so
           that SSSSIIIIGGGGHHHHUUUUPPPP is not sent to the job if the shell
           receives    a SSSSIIIIGGGGHHHHUUUUPPPP.  If no _j_o_b_s_p_e_c is present, and
           neither the ----aaaa nor the ----rrrr option    is supplied, the
           _c_u_r_r_e_n_t _j_o_b is used.  If    no _j_o_b_s_p_e_c is supplied,    the ----aaaa
           option means to remove or mark all jobs;    the ----rrrr option
           without a _j_o_b_s_p_e_c argument restricts operation to
           running jobs.  The return value is 0 unless a _j_o_b_s_p_e_c
           does not    specify    a valid    job.

      eeeecccchhhhoooo [----nnnneeeeEEEE] [_a_r_g ...]
           Output the _a_r_gs,    separated by spaces, followed by a
           newline.     The return status is always 0.     If ----nnnn is
           specified, the trailing newline is suppressed.  If the
           ----eeee option is given, interpretation of the following
           backslash-escaped characters is enabled.     The ----EEEE    option
           disables    the interpretation of these escape characters,
           even on systems where they are interpreted by default.
           eeeecccchhhhoooo does not interpret -------- to mean the end of options.
           eeeecccchhhhoooo interprets the following escape sequences:
           \\\\aaaa   alert (bell)
           \\\\bbbb   backspace
           \\\\cccc   suppress trailing newline
           \\\\eeee   an escape character
           \\\\ffff   form feed
           \\\\nnnn   new    line
           \\\\rrrr   carriage return
           \\\\tttt   horizontal tab
           \\\\vvvv   vertical tab
           \\\\\\\\   backslash
           \\\\_n_n_n the    character whose    ASCII code is the octal    value
            _n_n_n    (one to    three digits)
           \\\\xxxx_n_n_n
            the    character whose    ASCII code is the hexadecimal
            value _n_n_n (one to three digits)

      eeeennnnaaaabbbblllleeee [----aaaaddddnnnnppppssss] [----ffff _f_i_l_e_n_a_m_e]    [_n_a_m_e ...]
           Enable and disable builtin shell    commands.  Disabling a
           builtin allows a    disk command which has the same    name
           as a shell builtin to be    executed with specifying a
           full pathname, even though the shell normally searches
           for builtins before disk    commands.  If ----nnnn is used, each
           _n_a_m_e is disabled; otherwise, _n_a_m_e_s are enabled.    For
           example,    to use the tttteeeesssstttt    binary found via the PPPPAAAATTTTHHHH
           instead of the shell builtin version, run enable    -n
           test....  TTTThhhheeee ----ffff option means to load the new builtin



     Page 65                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           command _n_a_m_e from shared    object _f_i_l_e_n_a_m_e, on systems
           that support dynamic loading.  The ----dddd option will
           delete a    builtin    previously loaded with ----ffff.  If no _n_a_m_e
           arguments are given, or if the ----pppp option    is supplied, a
           list of shell builtins is printed.  With    no other
           option arguments, the list consists of all enabled
           shell builtins.    If ----nnnn is supplied, only    disabled
           builtins    are printed.  If ----aaaa is supplied, the list
           printed includes    all builtins, with an indication of
           whether or not each is enabled.    If ----ssss is supplied, the
           output is restricted to the POSIX _s_p_e_c_i_a_l builtins.
           The return value    is 0 unless a _n_a_m_e is not a shell
           builtin or there    is a problem loading a new builtin
           from a shared object.

      eeeevvvvaaaallll [_a_r_g ...]
           The _a_r_gs    are read and concatenated together into    a
           single command.    This command is    then read and executed
           by the shell, and its exit status is returned as    the
           value of    eeeevvvvaaaallll.  If there    are no _a_r_g_s, or    only null
           arguments, eeeevvvvaaaallll returns 0.

      eeeexxxxeeeecccc [----ccccllll] [----aaaa _n_a_m_e] [_c_o_m_m_a_n_d    [_a_r_g_u_m_e_n_t_s]]
           If _c_o_m_m_a_n_d is specified,    it replaces the    shell.    No new
           process is created.  The    _a_r_g_u_m_e_n_t_s become the arguments
           to _c_o_m_m_a_n_d.  If the ----llll option is    supplied, the shell
           places a    dash in    the zeroth arg passed to _c_o_m_m_a_n_d.
           This is what _l_o_g_i_n(1) does.  The    ----cccc option causes
           _c_o_m_m_a_n_d to be executed with an empty environment.  If
           ----aaaa is supplied, the shell passes    _n_a_m_e as    the zeroth
           argument    to the executed    command.  If _c_o_m_m_a_n_d cannot be
           executed    for some reason, a non-interactive shell
           exits, unless the shell option eeeexxxxeeeeccccffffaaaaiiiillll is enabled, in
           which case it returns failure.  An interactive shell
           returns failure if the file cannot be executed.    If
           _c_o_m_m_a_n_d is not specified, any redirections take effect
           in the current shell, and the return status is 0.  If
           there is    a redirection error, the return    status is 1.

      eeeexxxxiiiitttt [_n]
           Cause the shell to exit with a status of    _n.  If _n is
           omitted,    the exit status    is that    of the last command
           executed.  A trap on EEEEXXXXIIIITTTT is executed before the    shell
           terminates.

      eeeexxxxppppoooorrrrtttt [----ffffnnnn] [_n_a_m_e[=_w_o_r_d]] ...
      eeeexxxxppppoooorrrrtttt ----pppp
           The supplied _n_a_m_e_s are marked for automatic export to
           the environment of subsequently executed    commands.  If
           the ----ffff option is    given, the _n_a_m_e_s refer to functions.
           If no _n_a_m_e_s are given, or if the    ----pppp option is supplied,
           a list of all names that    are exported in    this shell is



     Page 66                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           printed.     The ----nnnn    option causes the export property to
           be removed from the named variables.  eeeexxxxppppoooorrrrtttt returns an
           exit status of 0    unless an invalid option is
           encountered, one    of the _n_a_m_e_s is    not a valid shell
           variable    name, or ----ffff is supplied    with a _n_a_m_e that is
           not a function.

      ffffcccc [----eeee _e_n_a_m_e]    [----nnnnllllrrrr] [_f_i_r_s_t] [_l_a_s_t]
      ffffcccc ----ssss    [_p_a_t=_r_e_p] [_c_m_d]
           Fix Command.  In    the first form,    a range    of commands
           from _f_i_r_s_t to _l_a_s_t is selected from the history list.
           _F_i_r_s_t and _l_a_s_t may be specified as a string (to locate
           the last    command    beginning with that string) or as a
           number (an index    into the history list, where a
           negative    number is used as an offset from the current
           command number).     If _l_a_s_t is not    specified it is    set to
           the current command for listing (so that    ffffcccc ----llll ----11110000
           prints the last 10 commands) and    to _f_i_r_s_t otherwise.
           If _f_i_r_s_t    is not specified it is set to the previous
           command for editing and -16 for listing.

           The ----nnnn option suppresses    the command numbers when
           listing.     The ----rrrr    option reverses    the order of the
           commands.  If the ----llll option is given, the commands are
           listed on standard output.  Otherwise, the editor given
           by _e_n_a_m_e    is invoked on a    file containing    those
           commands.  If _e_n_a_m_e is not given, the value of the
           FFFFCCCCEEEEDDDDIIIITTTT variable is used,    and the    value of EEEEDDDDIIIITTTTOOOORRRR    if
           FFFFCCCCEEEEDDDDIIIITTTT is not set.  If neither variable is set, _v_i is
           used.  When editing is complete,    the edited commands
           are echoed and executed.

           In the second form, _c_o_m_m_a_n_d is re-executed after    each
           instance    of _p_a_t is replaced by _r_e_p.  A useful alias to
           use with    this is    ``r=fc -s'', so    that typing ``r    cc''
           runs the    last command beginning with ``cc'' and typing
           ``r'' re-executes the last command.

           If the first form is used, the return value is 0    unless
           an invalid option is encountered    or _f_i_r_s_t or _l_a_s_t
           specify history lines out of range.  If the ----eeee option
           is supplied, the    return value is    the value of the last
           command executed    or failure if an error occurs with the
           temporary file of commands.  If the second form is
           used, the return    status is that of the command re-
           executed, unless    _c_m_d does not specify a valid history
           line, in    which case ffffcccc returns failure.

      ffffgggg [_j_o_b_s_p_e_c]
           Resume _j_o_b_s_p_e_c in the foreground, and make it the
           current job.  If    _j_o_b_s_p_e_c    is not present,    the shell's
           notion of the _c_u_r_r_e_n_t _j_o_b is used.  The return value is



     Page 67                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           that of the command placed into the foreground, or
           failure if run when job control is disabled or, when
           run with    job control enabled, if    _j_o_b_s_p_e_c    does not
           specify a valid job or _j_o_b_s_p_e_c specifies    a job that was
           started without job control.

      ggggeeeettttooooppppttttssss _o_p_t_s_t_r_i_n_g _n_a_m_e [_a_r_g_s]
           ggggeeeettttooooppppttttssss is used by shell    procedures to parse positional
           parameters.  _o_p_t_s_t_r_i_n_g contains the option letters to
           be recognized; if a letter is followed by a colon, the
           option is expected to have an argument, which should be
           separated from it by white space.  Each time it is
           invoked,    ggggeeeettttooooppppttttssss    places the next    option in the shell
           variable    _n_a_m_e, initializing _n_a_m_e    if it does not exist,
           and the index of    the next argument to be    processed into
           the variable OOOOPPPPTTTTIIIINNNNDDDD.  OOOOPPPPTTTTIIIINNNNDDDD is initialized to 1    each
           time the    shell or a shell script    is invoked.  When an
           option requires an argument, ggggeeeettttooooppppttttssss places that
           argument    into the variable OOOOPPPPTTTTAAAARRRRGGGG.  The shell does not
           reset OOOOPPPPTTTTIIIINNNNDDDD automatically; it must be manually reset
           between multiple    calls to ggggeeeettttooooppppttttssss within    the same shell
           invocation if a new set of parameters is    to be used.

           When the    end of options is encountered, ggggeeeettttooooppppttttssss exits
           with a return value greater than    zero.  OOOOPPPPTTTTIIIINNNNDDDD is set
           to the index of the first non-option argument, and nnnnaaaammmmeeee
           is set to ?.

           ggggeeeettttooooppppttttssss normally    parses the positional parameters, but
           if more arguments are given in _a_r_g_s, ggggeeeettttooooppppttttssss parses
           those instead.

           ggggeeeettttooooppppttttssss can report errors in two    ways.  If the first
           character of _o_p_t_s_t_r_i_n_g is a colon, _s_i_l_e_n_t error
           reporting is used.  In normal operation diagnostic
           messages    are printed when invalid options or missing
           option arguments    are encountered.  If the variable
           OOOOPPPPTTTTEEEERRRRRRRR is set to    0, no error messages will be
           displayed, even if the first character of _o_p_t_s_t_r_i_n_g is
           not a colon.

           If an invalid option is seen, ggggeeeettttooooppppttttssss places ? into
           _n_a_m_e and, if not    silent,    prints an error    message    and
           unsets OOOOPPPPTTTTAAAARRRRGGGG.  If ggggeeeettttooooppppttttssss is silent, the option
           character found is placed in OOOOPPPPTTTTAAAARRRRGGGG and no diagnostic
           message is printed.

           If a required argument is not found, and    ggggeeeettttooooppppttttssss    is not
           silent, a question mark (????) is placed in    _n_a_m_e, OOOOPPPPTTTTAAAARRRRGGGG
           is unset, and a diagnostic message is printed.  If
           ggggeeeettttooooppppttttssss is silent, then a colon (::::) is placed in    _n_a_m_e
           and OOOOPPPPTTTTAAAARRRRGGGG is set to the    option character found.



     Page 68                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           ggggeeeettttooooppppttttssss returns true if an option, specified or
           unspecified, is found.  It returns false    if the end of
           options is encountered or an error occurs.

      hhhhaaaasssshhhh [----rrrr] [----pppp    _f_i_l_e_n_a_m_e] [_n_a_m_e]
           For each    _n_a_m_e, the full file name of the    command    is
           determined by searching the directories in $$$$PPPPAAAATTTTHHHH    and
           remembered.  If the ----pppp option is    supplied, no path
           search is performed, and    _f_i_l_e_n_a_m_e is used as the    full
           file name of the    command.  The ----rrrr option    causes the
           shell to    forget all remembered locations.  If no
           arguments are given, information    about remembered
           commands    is printed.  The return    status is true unless
           a _n_a_m_e is not found or an invalid option    is supplied.

      hhhheeeellllpppp [_p_a_t_t_e_r_n]
           Display helpful information about builtin commands.  If
           _p_a_t_t_e_r_n is specified, hhhheeeellllpppp gives    detailed help on all
           commands    matching _p_a_t_t_e_r_n; otherwise help for all the
           builtins    and shell control structures is    printed.  The
           return status is    0 unless no command matches _p_a_t_t_e_r_n.

      hhhhiiiissssttttoooorrrryyyy [----cccc] [_n]
      hhhhiiiissssttttoooorrrryyyy ----aaaannnnrrrrwwww    [_f_i_l_e_n_a_m_e]
      hhhhiiiissssttttoooorrrryyyy ----pppp _a_r_g [_a_r_g ...]
      hhhhiiiissssttttoooorrrryyyy ----ssss _a_r_g [_a_r_g ...]
           With no options,    display    the command history list with
           line numbers.  Lines listed with    a **** have been
           modified.  An argument of _n lists only the last _n
           lines.  If _f_i_l_e_n_a_m_e is supplied,    it is used as the name
           of the history file; if not, the    value of HHHHIIIISSSSTTTTFFFFIIIILLLLEEEE is
           used.  Options, if supplied, have the following
           meanings:
           ----aaaa   Append the ``new'' history lines (history lines
            entered since the beginning    of the current bbbbaaaasssshhhh
            session) to    the history file.
           ----nnnn   Read the history lines not already read from the
            history file into the current history list.     These
            are    lines appended to the history file since the
            beginning of the current bbbbaaaasssshhhh session.
           ----rrrr   Read the contents of the history file and use them
            as the current history.
           ----wwww   Write the current history to the history file,
            overwriting    the history file's contents.
           ----cccc   Clear the history list by deleting all the
            entries.
           ----pppp   Perform history substitution on the    following _a_r_g_s
            and    display    the result on the standard output.
            Does not store the results in the history list.
            Each _a_r_g must be quoted to disable normal history
            expansion.
           ----ssss   Store the _a_r_g_s in the history list as a single



     Page 69                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



            entry.  The    last command in    the history list is
            removed before the _a_r_g_s are    added.

           The return value    is 0 unless an invalid option is
           encountered or an error occurs while reading or writing
           the history file.

      jjjjoooobbbbssss [----llllnnnnpppprrrrssss]    [ _j_o_b_s_p_e_c ... ]
      jjjjoooobbbbssss ----xxxx _c_o_m_m_a_n_d [ _a_r_g_s ... ]
           The first form lists the    active jobs.  The options have
           the following meanings:
           ----llll   List process IDs in    addition to the    normal
            information.
           ----pppp   List only the process ID of    the job's process
            group leader.
           ----nnnn   Display information    only about jobs    that have
            changed status since the user was last notified of
            their status.
           ----rrrr   Restrict output to running jobs.
           ----ssss   Restrict output to stopped jobs.

           If _j_o_b_s_p_e_c is given, output is restricted to
           information about that job.  The    return status is 0
           unless an invalid option    is encountered or an invalid
           _j_o_b_s_p_e_c is supplied.

           If the ----xxxx option    is supplied, jjjjoooobbbbssss replaces any _j_o_b_s_p_e_c
           found in    _c_o_m_m_a_n_d    or _a_r_g_s    with the corresponding process
           group ID, and executes _c_o_m_m_a_n_d passing it _a_r_g_s,
           returning its exit status.

      kkkkiiiillllllll [----ssss _s_i_g_s_p_e_c | ----nnnn    _s_i_g_n_u_m | ----_s_i_g_s_p_e_c] [_p_i_d    | _j_o_b_s_p_e_c] ...
      kkkkiiiillllllll ----llll [_s_i_g_s_p_e_c | _e_x_i_t__s_t_a_t_u_s]
           Send the    signal named by    _s_i_g_s_p_e_c    or _s_i_g_n_u_m to the
           processes named by _p_i_d or _j_o_b_s_p_e_c.  _s_i_g_s_p_e_c is either a
           signal name such    as SSSSIIIIGGGGKKKKIIIILLLLLLLL or a    signal number; _s_i_g_n_u_m
           is a signal number.  If _s_i_g_s_p_e_c is a signal name, the
           name may    be given with or without the SSSSIIIIGGGG prefix.  If
           _s_i_g_s_p_e_c is not present, then SSSSIIIIGGGGTTTTEEEERRRRMMMM is assumed.     An
           argument    of ----llll lists the    signal names.  If any
           arguments are supplied when ----llll is given,    the names of
           the signals corresponding to the    arguments are listed,
           and the return status is    0.  The    _e_x_i_t__s_t_a_t_u_s argument
           to ----llll is    a number specifying either a signal number or
           the exit    status of a process terminated by a signal.
           kkkkiiiillllllll returns true if at least one signal    was
           successfully sent, or false if an error occurs or an
           invalid option is encountered.

      lllleeeetttt _a_r_g [_a_r_g ...]
           Each _a_r_g    is an arithmetic expression to be evaluated
           (see AAAARRRRIIIITTTTHHHHMMMMEEEETTTTIIIICCCC EEEEVVVVAAAALLLLUUUUAAAATTTTIIIIOOOONNNN).  If    the last _a_r_g evaluates



     Page 70                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           to 0, lllleeeetttt returns 1; 0 is returned otherwise.

      llllooooccccaaaallll    [_n_a_m_e[=_v_a_l_u_e] ...]
           For each    argument, a local variable named _n_a_m_e is
           created,    and assigned _v_a_l_u_e.  When llllooooccccaaaallll    is used    within
           a function, it causes the variable _n_a_m_e to have a
           visible scope restricted    to that    function and its
           children.  With no operands, llllooooccccaaaallll writes a list    of
           local variables to the standard output.    It is an error
           to use llllooooccccaaaallll when not within a function.     The return
           status is 0 unless llllooooccccaaaallll    is used    outside    a function, or
           an invalid _n_a_m_e is supplied.

      llllooooggggoooouuuutttt
           Exit a login shell.

      ppppooooppppdddd [-nnnn] [+_n] [-_n]
           Removes entries from the    directory stack.  With no
           arguments, removes the top directory from the stack,
           and performs a ccccdddd to the    new top    directory.  Arguments,
           if supplied, have the following meanings:
           ++++_n   Removes the    _nth entry counting from    the left of
            the    list shown by ddddiiiirrrrssss, starting with zero.     For
            example: ``popd +0'' removes the first directory,
            ``popd +1''    the second.
           ----_n   Removes the    _nth entry counting from    the right of
            the    list shown by ddddiiiirrrrssss, starting with zero.     For
            example: ``popd -0'' removes the last directory,
            ``popd -1''    the next to last.
           ----nnnn   Suppresses the normal change of directory when
            removing directories from the stack, so that only
            the    stack is manipulated.

           If the ppppooooppppdddd command is successful, a ddddiiiirrrrssss is performed
           as well,    and the    return status is 0.  ppppooooppppdddd returns
           false if    an invalid option is encountered, the
           directory stack is empty, a non-existent    directory
           stack entry is specified, or the    directory change
           fails.

      pppprrrriiiinnnnttttffff _f_o_r_m_a_t    [_a_r_g_u_m_e_n_t_s]
           Write the formatted _a_r_g_u_m_e_n_t_s to    the standard output
           under the control of the    _f_o_r_m_a_t.     The _f_o_r_m_a_t is a
           character string    which contains three types of objects:
           plain characters, which are simply copied to standard
           output, character escape    sequences, which are converted
           and copied to the standard output, and format
           specifications, each of which causes printing of    the
           next successive _a_r_g_u_m_e_n_t.  In addition to the standard
           _p_r_i_n_t_f(1) formats, %b causes pppprrrriiiinnnnttttffff to expand backslash
           escape sequences    in the corresponding _a_r_g_u_m_e_n_t, and %q
           causes pppprrrriiiinnnnttttffff to    output the corresponding _a_r_g_u_m_e_n_t in a



     Page 71                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           format that can be reused as shell input.

           The _f_o_r_m_a_t is reused as necessary to consume all    of the
           _a_r_g_u_m_e_n_t_s.  If the _f_o_r_m_a_t requires more _a_r_g_u_m_e_n_t_s than
           are supplied, the extra format specifications behave as
           if a zero value or null string, as appropriate, had
           been supplied.

      ppppuuuusssshhhhdddd    [----nnnn] [_d_i_r]
      ppppuuuusssshhhhdddd    [----nnnn] [+_n] [-_n]
           Adds a directory    to the top of the directory stack, or
           rotates the stack, making the new top of    the stack the
           current working directory.  With    no arguments,
           exchanges the top two directories and returns 0,    unless
           the directory stack is empty.  Arguments, if supplied,
           have the    following meanings:
           ++++_n   Rotates the    stack so that the _nth directory
            (counting from the left of the list    shown by ddddiiiirrrrssss,
            starting with zero)    is at the top.
           ----_n   Rotates the    stack so that the _nth directory
            (counting from the right of    the list shown by
            ddddiiiirrrrssss, starting with    zero) is at the    top.
           ----nnnn   Suppresses the normal change of directory when
            adding directories to the stack, so    that only the
            stack is manipulated.
           ddddiiiirrrr  Adds _d_i_r to    the directory stack at the top,    making
            it the new current working directory.

           If the ppppuuuusssshhhhdddd command is successful, a ddddiiiirrrrssss is performed
           as well.     If the    first form is used, ppppuuuusssshhhhdddd returns 0
           unless the cd to    _d_i_r fails.  With the second form,
           ppppuuuusssshhhhdddd returns 0 unless the directory stack is empty, a
           non-existent directory stack element is specified, or
           the directory change to the specified new current
           directory fails.

      ppppwwwwdddd [----LLLLPPPP]
           Print the absolute file name of the current working
           directory.  The file name printed contains no symbolic
           links if    the ----PPPP option is supplied or the ----oooo pppphhhhyyyyssssiiiiccccaaaallll
           option to the sssseeeetttt builtin command is enabled.  If the
           ----LLLL option is used, symbolic links are followed.    The
           return status is    0 unless an error occurs while reading
           the name    of the current directory or an invalid option
           is supplied.

      rrrreeeeaaaadddd [----eeeerrrr] [----aaaa _a_n_a_m_e]    [----pppp _p_r_o_m_p_t] [_n_a_m_e ...]
           One line    is read    from the standard input, and the first
           word is assigned    to the first _n_a_m_e, the second word to
           the second _n_a_m_e,    and so on, with    leftover words and
           their intervening separators assigned to    the last _n_a_m_e.
           If there    are fewer words    read from the standard input



     Page 72                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           than names, the remaining names are assigned empty
           values.    The characters in IIIIFFFFSSSS are used to split    the
           line into words.     The backslash character (\\\\) may be
           used to remove any special meaning for the next
           character read and for line continuation.  Options, if
           supplied, have the following meanings:
           ----rrrr   Backslash does not act as an escape    character.
            The    backslash is considered    to be part of the
            line.  In particular, a backslash-newline pair may
            not    be used    as a line continuation.
           ----pppp   Display _p_r_o_m_p_t, without a trailing newline,    before
            attempting to read any input.  The prompt is
            displayed only if input is coming from a terminal.
           ----aaaa   The    words are assigned to sequential indices of
            the    array variable _a_n_a_m_e, starting at 0.  _a_n_a_m_e is
            unset before any new values    are assigned.  Other
            _n_a_m_e arguments are ignored.
           ----eeee   If the standard input is coming from a terminal,
            rrrreeeeaaaaddddlllliiiinnnneeee (see RRRREEEEAAAADDDDLLLLIIIINNNNEEEE above) is used to obtain
            the    line.

           If no _n_a_m_e_s are supplied, the line read is assigned to
           the variable RRRREEEEPPPPLLLLYYYY.  The    return code is zero, unless
           end-of-file is encountered.

      rrrreeeeaaaaddddoooonnnnllllyyyy [----aaaappppffff] [_n_a_m_e    ...]
           The given _n_a_m_e_s are marked readonly; the    values of
           these _n_a_m_e_s may not be changed by subsequent
           assignment.  If the ----ffff option is    supplied, the
           functions corresponding to the _n_a_m_e_s are    so marked.
           The ----aaaa option restricts the variables to    arrays.     If no
           _n_a_m_e arguments are given, or if the ----pppp option is
           supplied, a list    of all readonly    names is printed.  The
           ----pppp option causes    output to be displayed in a format
           thatmay be reused as input.  The    return status is 0
           unless an invalid option    is encountered,    one of the
           _n_a_m_e_s is    not a valid shell variable name, or ----ffff is
           supplied    with a _n_a_m_e that is not    a function.

      rrrreeeettttuuuurrrrnnnn [_n]
           Causes a    function to exit with the return value
           specified by _n.    If _n is    omitted, the return status is
           that of the last    command    executed in the    function body.
           If used outside a function, but during execution    of a
           script by the .... (ssssoooouuuurrrrcccceeee)    command, it causes the shell
           to stop executing that script and return    either _n or
           the exit    status of the last command executed within the
           script as the exit status of the    script.     If used
           outside a function and not during execution of a    script
           by ...., the return    status is false.

      sssseeeetttt [--------aaaabbbbeeeeffffhhhhkkkkmmmmnnnnppppttttuuuuvvvvxxxxBBBBCCCCHHHHPPPP] [----oooo    _o_p_t_i_o_n]    [_a_r_g ...]



     Page 73                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           Without options,    the name and value of each shell
           variable    are displayed in a format that can be reused
           as input.  The output is    sorted according to the
           current locale.    When options are specified, they set
           or unset    shell attributes.  Any arguments remaining
           after the options are processed are treated as values
           for the positional parameters and are assigned, in
           order, to $$$$1111, $$$$2222, ............ $$$$_n.  Options, if specified, have
           the following meanings:
           ----aaaa      Automatically mark variables which are modified
               or created for export to    the environment    of
               subsequent commands.
           ----bbbb      Report the status of terminated background jobs
               immediately, rather than    before the next
               primary prompt.    This is    effective only when
               job control is enabled.
           ----eeee      Exit immediately    if a _s_i_m_p_l_e _c_o_m_m_a_n_d (see SSSSHHHHEEEELLLLLLLL
               GGGGRRRRAAAAMMMMMMMMAAAARRRR above) exits with a non-zero status.
               The shell does not exit if the command that
               fails is    part of    an _u_n_t_i_l or _w_h_i_l_e loop,    part
               of an _i_f    statement, part    of a &&&&&&&&    or |||||||| list, or
               if the command's    return value is    being inverted
               via !!!!.
           ----ffff      Disable pathname    expansion.
           ----hhhh      Remember    the location of    commands as they are
               looked up for execution.     This is enabled by
               default.
           ----kkkk      All arguments in    the form of assignment
               statements are placed in    the environment    for a
               command,    not just those that precede the
               command name.
           ----mmmm      Monitor mode.  Job control is enabled.  This
               option is on by default for interactive shells
               on systems that support it (see JJJJOOOOBBBB CCCCOOOONNNNTTTTRRRROOOOLLLL
               above).    Background processes run in a separate
               process group and a line    containing their exit
               status is printed upon their completion.
           ----nnnn      Read commands but do not    execute    them.  This
               may be used to check a shell script for syntax
               errors.    This is    ignored    by interactive shells.
           ----oooo _o_p_t_i_o_n-_n_a_m_e
               The _o_p_t_i_o_n-_n_a_m_e can be one of the following:
               aaaalllllllleeeexxxxppppoooorrrrtttt
                   Same as ----aaaa.
               bbbbrrrraaaacccceeeeeeeexxxxppppaaaannnndddd
                   Same as ----BBBB.
               eeeemmmmaaaaccccssss   Use an emacs-style command line editing
                   interface.  This    is enabled by default
                   when the    shell is interactive, unless
                   the shell is started with the
                   --------nnnnooooeeeeddddiiiittttiiiinnnngggg option.
               eeeerrrrrrrreeeexxxxiiiitttt Same as ----eeee.



     Page 74                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



               hhhhaaaasssshhhhaaaallllllll Same as ----hhhh.
               hhhhiiiisssstttteeeexxxxppppaaaannnndddd
                   Same as ----HHHH.
               hhhhiiiissssttttoooorrrryyyy Enable command history, as described
                   above under HHHHIIIISSSSTTTTOOOORRRRYYYY.  This option is on
                   by default in interactive shells.
               iiiiggggnnnnoooorrrreeeeeeeeooooffff
                   The effect is as    if the shell command
                   IGNOREEOF=10 had    been executed (see
                   SSSShhhheeeellllllll VVVVaaaarrrriiiiaaaabbbblllleeeessss above).
               kkkkeeeeyyyywwwwoooorrrrdddd Same as ----kkkk.
               mmmmoooonnnniiiittttoooorrrr Same as ----mmmm.
               nnnnoooocccclllloooobbbbbbbbeeeerrrr
                   Same as ----CCCC.
               nnnnooooeeeexxxxeeeecccc  Same as ----nnnn.
               nnnnoooogggglllloooobbbb  Same as ----ffff.
               nnnnoooottttiiiiffffyyyy  Same as ----bbbb.
               nnnnoooouuuunnnnsssseeeetttt Same as ----uuuu.
               oooonnnneeeeccccmmmmdddd  Same as ----tttt.
               pppphhhhyyyyssssiiiiccccaaaallll
                   Same as ----PPPP.
               ppppoooossssiiiixxxx   Change the behavior of bbbbaaaasssshhhh where the
                   default operation differs from the
                   POSIX 1003.2 standard to    match the
                   standard.
               pppprrrriiiivvvviiiilllleeeeggggeeeedddd
                   Same as ----pppp.
               vvvveeeerrrrbbbboooosssseeee Same as ----vvvv.
               vvvviiii      Use a vi-style command line editing
                   interface.
               xxxxttttrrrraaaacccceeee  Same as ----xxxx.

               If ----oooo is    supplied with no _o_p_t_i_o_n-_n_a_m_e, the
               values of the current options are printed.  If
               ++++oooo is supplied with no _o_p_t_i_o_n-_n_a_m_e, a series of
               sssseeeetttt commands to recreate    the current option
               settings    is displayed on    the standard output.
           ----pppp      Turn on _p_r_i_v_i_l_e_g_e_d mode.     In this mode, the
               $$$$EEEENNNNVVVV and    $$$$BBBBAAAASSSSHHHH____EEEENNNNVVVV files    are not    processed,
               shell functions are not inherited from the
               environment, and    the SSSSHHHHEEEELLLLLLLLOOOOPPPPTTTTSSSS variable,    if it
               appears in the environment, is ignored.    If the
               shell is    started    with the effective user
               (group) id not equal to the real    user (group)
               id, and the ----pppp option is    not supplied, these
               actions are taken and the effective user    id is
               set to the real user id.     If the    ----pppp option is
               supplied    at startup, the    effective user id is
               not reset.  Turning this    option off causes the
               effective user and group    ids to be set to the
               real user and group ids.
           ----tttt      Exit after reading and executing    one command.



     Page 75                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           ----uuuu      Treat unset variables as    an error when
               performing parameter expansion.    If expansion
               is attempted on an unset    variable, the shell
               prints an error message,    and, if    not
               interactive, exits with a non-zero status.
           ----vvvv      Print shell input lines as they are read.
           ----xxxx      After expanding each _s_i_m_p_l_e _c_o_m_m_a_n_d, display
               the expanded value of PPPPSSSS4444, followed by the
               command and its expanded    arguments.
           ----BBBB      The shell performs brace    expansion (see BBBBrrrraaaacccceeee
               EEEExxxxppppaaaannnnssssiiiioooonnnn above).  This is on by    default.
           ----CCCC      If set, bbbbaaaasssshhhh does not overwrite an existing
               file with the >>>>,    >>>>&&&&, and    <<<<>>>> redirection
               operators.  This    may be overridden when
               creating    output files by    using the redirection
               operator    >>>>|||| instead of >>>>.
           ----HHHH      Enable !!!!    style history substitution.  This
               option is on by default when the    shell is
               interactive.
           ----PPPP      If set, the shell does not follow symbolic
               links when executing commands such as ccccdddd    that
               change the current working directory.  It uses
               the physical directory structure    instead.  By
               default,    bbbbaaaasssshhhh follows the logical chain of
               directories when    performing commands which
               change the current directory.
           --------      If no arguments follow this option, then    the
               positional parameters are unset.     Otherwise,
               the positional parameters are set to the    _a_r_gs,
               even if some of them begin with a ----.
           ----       Signal the end of options, cause    all remaining
               _a_r_gs to be assigned to the positional
               parameters.  The    ----xxxx and ----vvvv options are turned
               off.  If    there are no _a_r_gs, the positional
               parameters remain unchanged.

           The options are off by default unless otherwise noted.
           Using + rather than - causes these options to be    turned
           off.  The options can also be specified as arguments to
           an invocation of    the shell.  The    current    set of options
           may be found in $$$$----.  The    return status is always    true
           unless an invalid option    is encountered.

      sssshhhhiiiifffftttt    [_n]
           The positional parameters from _n+1 ... are renamed to
           $$$$1111 ................ Parameters represented by the numbers $$$$####    down
           to $$$$####-_n+1 are unset.  _n must be a non-negative number
           less than or equal to $$$$####.  If _n is 0, no    parameters are
           changed.     If _n is not given, it is assumed to be    1.  If
           _n is greater than $$$$####, the positional parameters are not
           changed.     The return status is greater than zero    if _n
           is greater than $$$$#### or less than zero; otherwise 0.



     Page 76                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      sssshhhhoooopppptttt    [----ppppqqqqssssuuuu]    [----oooo] [_o_p_t_n_a_m_e ...]
           Toggle the values of variables controlling optional
           shell behavior.    With no    options, or with the ----pppp
           option, a list of all settable options is displayed,
           with an indication of whether or    not each is set.  The
           ----pppp option causes    output to be displayed in a form that
           may be reused as    input.    Other options have the
           following meanings:
           ----ssss   Enable (set) each _o_p_t_n_a_m_e.
           ----uuuu   Disable (unset) each _o_p_t_n_a_m_e.
           ----qqqq   Suppresses normal output (quiet mode); the return
            status indicates whether the _o_p_t_n_a_m_e is set    or
            unset.  If multiple    _o_p_t_n_a_m_e    arguments are given
            with ----qqqq, the return    status is zero if all _o_p_t_n_a_m_e_s
            are    enabled; non-zero otherwise.
           ----oooo   Restricts the values of _o_p_t_n_a_m_e to be those
            defined for    the ----oooo option to the sssseeeetttt builtin.

           If either ----ssss or ----uuuu is used with no _o_p_t_n_a_m_e arguments,
           the display is limited to those options which are set
           or unset, respectively.    Unless otherwise noted,    the
           sssshhhhoooopppptttt options are disabled (unset) by default.

           The return status when listing options is zero if all
           _o_p_t_n_a_m_e_s    are enabled, non-zero otherwise.  When setting
           or unsetting options, the return    status is zero unless
           an _o_p_t_n_a_m_e is not a valid shell option.

           The list    of sssshhhhoooopppptttt options is:

           ccccddddaaaabbbblllleeee____vvvvaaaarrrrssss
               If set, an argument to the ccccdddd builtin command
               that is not a directory is assumed to be    the
               name of a variable whose    value is the directory
               to change to.
           ccccddddssssppppeeeellllllll If set, minor errors in the spelling of a
               directory component in a    ccccdddd command will    be
               corrected.  The errors checked for are
               transposed characters, a    missing    character, and
               one character too many.    If a correction    is
               found, the corrected file name is printed, and
               the command proceeds.  This option is only used
               by interactive shells.
           cccchhhheeeecccckkkkhhhhaaaasssshhhh
               If set, bbbbaaaasssshhhh checks that    a command found    in the
               hash table exists before    trying to execute it.
               If a hashed command no longer exists, a normal
               path search is performed.
           cccchhhheeeecccckkkkwwwwiiiinnnnssssiiiizzzzeeee
               If set, bbbbaaaasssshhhh checks the window size after each
               command and, if necessary, updates the values
               of LLLLIIIINNNNEEEESSSS    and CCCCOOOOLLLLUUUUMMMMNNNNSSSS.



     Page 77                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           ccccmmmmddddhhhhiiiisssstttt If set, bbbbaaaasssshhhh attempts to    save all lines of a
               multiple-line command in    the same history
               entry.  This allows easy    re-editing of multi-
               line commands.
           ddddoooottttgggglllloooobbbb If set, bbbbaaaasssshhhh includes filenames beginning with
               a `.' in    the results of pathname    expansion.
           eeeexxxxeeeeccccffffaaaaiiiillll
               If set, a non-interactive shell will not    exit
               if it cannot execute the    file specified as an
               argument    to the eeeexxxxeeeecccc builtin command.  An
               interactive shell does not exit if eeeexxxxeeeecccc fails.
           eeeexxxxppppaaaannnndddd____aaaalllliiiiaaaasssseeeessss
               If set, aliases are expanded as described above
               under AAAALLLLIIIIAAAASSSSEEEESSSS.  This option is enabled by
               default for interactive shells.
           eeeexxxxttttgggglllloooobbbb If set, the extended pattern matching features
               described above under PPPPaaaatttthhhhnnnnaaaammmmeeee EEEExxxxppppaaaannnnssssiiiioooonnnn    are
               enabled.
           hhhhiiiissssttttaaaappppppppeeeennnndddd
               If set, the history list    is appended to the
               file named by the value of the HHHHIIIISSSSTTTTFFFFIIIILLLLEEEE
               variable    when the shell exits, rather than
               overwriting the file.
           hhhhiiiissssttttrrrreeeeeeeeddddiiiitttt
               If set, and rrrreeeeaaaaddddlllliiiinnnneeee is being used, a user is
               given the opportunity to    re-edit    a failed
               history substitution.
           hhhhiiiissssttttvvvveeeerrrriiiiffffyyyy
               If set, and rrrreeeeaaaaddddlllliiiinnnneeee is being used, the results
               of history substitution are not immediately
               passed to the shell parser.  Instead, the
               resulting line is loaded    into the rrrreeeeaaaaddddlllliiiinnnneeee
               editing buffer, allowing    further    modification.
           hhhhoooossssttttccccoooommmmpppplllleeeetttteeee
               If set, and rrrreeeeaaaaddddlllliiiinnnneeee is being used, bbbbaaaasssshhhh    will
               attempt to perform hostname completion when a
               word containing a @@@@ is being completed (see
               CCCCoooommmmpppplllleeeettttiiiinnnngggg under    RRRREEEEAAAADDDDLLLLIIIINNNNEEEE above).  This is
               enabled by default.
           hhhhuuuuppppoooonnnneeeexxxxiiiitttt
               If set, bbbbaaaasssshhhh will send SSSSIIIIGGGGHHHHUUUUPPPP to    all jobs when
               an interactive login shell exits.
           iiiinnnntttteeeerrrraaaaccccttttiiiivvvveeee____ccccoooommmmmmmmeeeennnnttttssss
               If set, allow a word beginning with #### to    cause
               that word and all remaining characters on that
               line to be ignored in an    interactive shell (see
               CCCCOOOOMMMMMMMMEEEENNNNTTTTSSSS    above).     This option is    enabled    by
               default.
           lllliiiitttthhhhiiiisssstttt If set, and the ccccmmmmddddhhhhiiiisssstttt option is enabled,
               multi-line commands are saved to    the history
               with embedded newlines rather than using
               semicolon separators where possible.



     Page 78                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           mmmmaaaaiiiillllwwwwaaaarrrrnnnn
               If set, and a file that bbbbaaaasssshhhh is checking    for
               mail has    been accessed since the    last time it
               was checked, the    message    ``The mail in _m_a_i_l_f_i_l_e
               has been    read'' is displayed.
           nnnnooooccccaaaasssseeeegggglllloooobbbb
               If set, bbbbaaaasssshhhh matches filenames in a
               case-insensitive    fashion    when performing
               pathname    expansion (see PPPPaaaatttthhhhnnnnaaaammmmeeee    EEEExxxxppppaaaannnnssssiiiioooonnnn
               above).
           nnnnuuuullllllllgggglllloooobbbb
               If set, bbbbaaaasssshhhh allows patterns which match    no
               files (see PPPPaaaatttthhhhnnnnaaaammmmeeee EEEExxxxppppaaaannnnssssiiiioooonnnn above) to expand
               to a null string, rather    than themselves.
           pppprrrroooommmmppppttttvvvvaaaarrrrssss
               If set, prompt strings undergo variable and
               parameter expansion after being expanded    as
               described in PPPPRRRROOOOMMMMPPPPTTTTIIIINNNNGGGG above.  This option is
               enabled by default.
           rrrreeeessssttttrrrriiiicccctttteeeedddd____sssshhhheeeellllllll
               The shell sets this option if it    is started in
               restricted mode (see RRRREEEESSSSTTTTRRRRIIIICCCCTTTTEEEEDDDD SSSSHHHHEEEELLLLLLLL below).
               The value may not be changed.  This is not
               reset when the startup files are    executed,
               allowing    the startup files to discover whether
               or not a    shell is restricted.
           sssshhhhiiiifffftttt____vvvveeeerrrrbbbboooosssseeee
               If set, the sssshhhhiiiifffftttt builtin prints    an error
               message when the    shift count exceeds the    number
               of positional parameters.
           ssssoooouuuurrrrcccceeeeppppaaaatttthhhh
               If set, the ssssoooouuuurrrrcccceeee (....) builtin uses the value
               of PPPPAAAATTTTHHHH to find the directory containing    the
               file supplied as    an argument.  This option is
               enabled by default.
      ssssuuuussssppppeeeennnndddd [----ffff]
           Suspend the execution of    this shell until it receives a
           SSSSIIIIGGGGCCCCOOOONNNNTTTT signal.    The ----ffff option says not to complain if
           this is a login shell; just suspend anyway.  The    return
           status is 0 unless the shell is a login shell and ----ffff is
           not supplied, or    if job control is not enabled.
      tttteeeesssstttt _e_x_p_r
      [[[[ _e_x_p_r ]]]]
           Return a    status of 0 or 1 depending on the evaluation
           of the conditional expression _e_x_p_r.  Each operator and
           operand must be a separate argument.  Expressions are
           composed    of the primaries described above under
           CCCCOOOONNNNDDDDIIIITTTTIIIIOOOONNNNAAAALLLL EEEEXXXXPPPPRRRREEEESSSSSSSSIIIIOOOONNNNSSSS.

           Expressions may be combined using the following
           operators, listed in decreasing order of    precedence.
           !!!! _e_x_p_r



     Page 79                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



            True if _e_x_p_r is false.
           (((( _e_x_p_r ))))
            Returns the    value of _e_x_p_r.    This may be used to
            override the normal    precedence of operators.
           _e_x_p_r_1 -aaaa    _e_x_p_r_2
            True if both _e_x_p_r_1 and _e_x_p_r_2 are true.
           _e_x_p_r_1 -oooo    _e_x_p_r_2
            True if either _e_x_p_r_1 or _e_x_p_r_2 is true.

           tttteeeesssstttt and    [[[[ evaluate conditional expressions using a set
           of rules    based on the number of arguments.

           0 arguments
            The    expression is false.
           1 argument
            The    expression is true if and only if the argument
            is not null.
           2 arguments
            If the first argument is !!!!,    the expression is true
            if and only    if the second argument is null.     If
            the    first argument is one of the unary conditional
            operators listed above under CCCCOOOONNNNDDDDIIIITTTTIIIIOOOONNNNAAAALLLL
            EEEEXXXXPPPPRRRREEEESSSSSSSSIIIIOOOONNNNSSSS, the expression    is true    if the unary
            test is true.  If the first    argument is not    a
            valid unary    conditional operator, the expression
            is false.
           3 arguments
            If the second argument is one of the binary
            conditional    operators listed above under
            CCCCOOOONNNNDDDDIIIITTTTIIIIOOOONNNNAAAALLLL    EEEEXXXXPPPPRRRREEEESSSSSSSSIIIIOOOONNNNSSSS, the result    of the
            expression is the result of    the binary test    using
            the    first and third    arguments as operands.    If the
            first argument is !!!!, the value is the negation of
            the    two-argument test using    the second and third
            arguments.    If the first argument is exactly (((( and
            the    third argument is exactly )))), the result    is the
            one-argument test of the second argument.
            Otherwise, the expression is false.     The ----aaaa    and ----oooo
            operators are considered binary operators in this
            case.
           4 arguments
            If the first argument is !!!!,    the result is the
            negation of    the three-argument expression composed
            of the remaining arguments.     Otherwise, the
            expression is parsed and evaluated according to
            precedence using the rules listed above.
           5 or more arguments
            The    expression is parsed and evaluated according
            to precedence using    the rules listed above.

      ttttiiiimmmmeeeessss
           Print the accumulated user and system times for the



     Page 80                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           shell and for processes run from    the shell.  The    return
           status is 0.

      ttttrrrraaaapppp [----llllpppp] [_a_r_g] [_s_i_g_s_p_e_c ...]
           The command _a_r_g is to be    read and executed when the
           shell receives signal(s)    _s_i_g_s_p_e_c.  If _a_r_g is absent or
           ----, all specified    signals    are reset to their original
           values (the values they had upon    entrance to the
           shell).    If _a_r_g is the null string the signal specified
           by each _s_i_g_s_p_e_c is ignored by the shell and by the
           commands    it invokes.  If    _a_r_g is ----pppp then the trap
           commands    associated with    each _s_i_g_s_p_e_c are displayed.
           If no arguments are supplied or if only ----pppp is given,
           ttttrrrraaaapppp prints the list of commands    associated with    each
           signal number.  Each _s_i_g_s_p_e_c is either a    signal name
           defined in <_s_i_g_n_a_l._h>, or a signal number.  If a
           _s_i_g_s_p_e_c is EEEEXXXXIIIITTTT (0) the command _a_r_g is executed on exit
           from the    shell.    If a _s_i_g_s_p_e_c is    DDDDEEEEBBBBUUUUGGGG, the command _a_r_g
           is executed after every _s_i_m_p_l_e _c_o_m_m_a_n_d (see SSSSHHHHEEEELLLLLLLL
           GGGGRRRRAAAAMMMMMMMMAAAARRRR above).    The ----llll option causes the shell to
           print a list of signal names and    their corresponding
           numbers.     Signals ignored upon entry to the shell
           cannot be trapped or reset.  Trapped signals are    reset
           to their    original values    in a child process when    it is
           created.     The return status is false if any _s_i_g_s_p_e_c is
           invalid;    otherwise ttttrrrraaaapppp returns true.

      ttttyyyyppppeeee [----aaaattttpppp] _n_a_m_e [_n_a_m_e ...]
           With no options,    indicate how each _n_a_m_e would be
           interpreted if used as a    command    name.  If the ----tttt
           option is used, ttttyyyyppppeeee prints a string which is one of
           _a_l_i_a_s, _k_e_y_w_o_r_d, _f_u_n_c_t_i_o_n, _b_u_i_l_t_i_n, or _f_i_l_e if _n_a_m_e is
           an alias, shell reserved    word, function,    builtin, or
           disk file, respectively.     If the    _n_a_m_e is    not found,
           then nothing is printed,    and an exit status of false is
           returned.  If the ----pppp option is used, ttttyyyyppppeeee either
           returns the name    of the disk file that would be
           executed    if _n_a_m_e    were specified as a command name, or
           nothing if type -t name _w_o_u_l_d _n_o_t _r_e_t_u_r_n    _f_i_l_e.  If a
           command is hashed, ----pppp prints the    hashed value, not
           necessarily the file that appears first in PPPPAAAATTTTHHHH.     If
           the ----aaaa option is    used, ttttyyyyppppeeee prints all of the places
           that contain an executable named    _n_a_m_e.  This includes
           aliases and functions, if and only if the ----pppp option is
           not also    used.  The table of hashed commands is not
           consulted when using ----aaaa.     ttttyyyyppppeeee returns true if any of
           the arguments are found,    false if none are found.

      uuuulllliiiimmmmiiiitttt [----SSSSHHHHaaaaccccddddffffllllmmmmnnnnppppssssttttuuuuvvvv [_l_i_m_i_t]]
           Provides    control    over the resources available to    the
           shell and to processes started by it, on    systems    that
           allow such control.  The    value of _l_i_m_i_t can be a    number



     Page 81                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



           in the unit specified for the resource, or the value
           uuuunnnnlllliiiimmmmiiiitttteeeedddd.  The ----HHHH and ----SSSS options specify that the hard
           or soft limit is    set for    the given resource.  A hard
           limit cannot be increased once it is set; a soft    limit
           may be increased    up to the value    of the hard limit.  If
           neither ----HHHH nor ----SSSS is specified, both the    soft and hard
           limits are set.    If _l_i_m_i_t is omitted, the current value
           of the soft limit of the    resource is printed, unless
           the ----HHHH option is    given.    When more than one resource is
           specified, the limit name and unit are printed before
           the value.  Other options are interpreted as follows:
           ----aaaa   All    current    limits are reported
           ----cccc   The    maximum    size of    core files created
           ----dddd   The    maximum    size of    a process's data segment
           ----ffff   The    maximum    size of    files created by the shell
           ----llll   The    maximum    size that may be locked    into memory
           ----mmmm   The    maximum    resident set size
           ----nnnn   The    maximum    number of open file descriptors    (most
            systems do not allow this value to be set)
           ----pppp   The    pipe size in 512-byte blocks (this may not be
            set)
           ----ssss   The    maximum    stack size
           ----tttt   The    maximum    amount of cpu time in seconds
           ----uuuu   The    maximum    number of processes available to a
            single user
           ----vvvv   The    maximum    amount of virtual memory available to
            the    shell

           If _l_i_m_i_t    is given, it is    the new    value of the specified
           resource    (the ----aaaa    option is display only).  If no    option
           is given, then ----ffff is assumed.  Values are in 1024-byte
           increments, except for ----tttt, which    is in seconds, ----pppp,
           which is    in units of 512-byte blocks, and ----nnnn and    ----uuuu,
           which are unscaled values.  The return status is    0
           unless an invalid option    is encountered,    a non-numeric
           argument    other than uuuunnnnlllliiiimmmmiiiitttteeeedddd is    supplied as _l_i_m_i_t, or
           an error    occurs while setting a new limit.

      uuuummmmaaaasssskkkk    [----pppp] [----SSSS] [_m_o_d_e]
           The user    file-creation mask is set to _m_o_d_e.  If _m_o_d_e
           begins with a digit, it is interpreted as an octal
           number; otherwise it is interpreted as a    symbolic mode
           mask similar to that accepted by    _c_h_m_o_d(1).  If _m_o_d_e is
           omitted,    or if the ----SSSS option is supplied, the current
           value of    the mask is printed.  The ----SSSS option causes the
           mask to be printed in symbolic form; the    default    output
           is an octal number.  If the ----pppp option is    supplied, and
           _m_o_d_e is omitted,    the output is in a form    that may be
           reused as input.     The return status is 0    if the mode
           was successfully    changed    or if no _m_o_d_e argument was
           supplied, and false otherwise.




     Page 82                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      uuuunnnnaaaalllliiiiaaaassss [-aaaa] [_n_a_m_e ...]
           Remove _n_a_m_es from the list of defined aliases.  If ----aaaa
           is supplied, all    alias definitions are removed.    The
           return value is true unless a supplied _n_a_m_e is not a
           defined alias.

      uuuunnnnsssseeeetttt    [-ffffvvvv] [_n_a_m_e ...]
           For each    _n_a_m_e, remove the corresponding variable    or
           function.  If no    options    are supplied, or the ----vvvv    option
           is given, each _n_a_m_e refers to a shell variable.    Read-
           only variables may not be unset.     If ----ffff is specifed,
           each _n_a_m_e refers    to a shell function, and the function
           definition is removed.  Each unset variable or function
           is removed from the environment passed to subsequent
           commands.  If any of RRRRAAAANNNNDDDDOOOOMMMM, SSSSEEEECCCCOOOONNNNDDDDSSSS, LLLLIIIINNNNEEEENNNNOOOO, HHHHIIIISSSSTTTTCCCCMMMMDDDD,
           or DDDDIIIIRRRRSSSSTTTTAAAACCCCKKKK are unset, they lose    their special
           properties, even    if they    are subsequently reset.     The
           exit status is true unless a _n_a_m_e does not exist    or is
           readonly.

      wwwwaaaaiiiitttt [_n]
           Wait for    the specified process and return its
           termination status.  _n may be a process ID or a job
           specification; if a job spec is given, all processes in
           that job's pipeline are waited for.  If _n is not    given,
           all currently active child processes are    waited for,
           and the return status is    zero.  If _n specifies a    non-
           existent    process    or job,    the return status is 127.
           Otherwise, the return status is the exit    status of the
           last process or job waited for.

     RRRREEEESSSSTTTTRRRRIIIICCCCTTTTEEEEDDDD    SSSSHHHHEEEELLLLLLLL
      If bbbbaaaasssshhhh is started with the name rrrrbbbbaaaasssshhhh, or the ----rrrr option is
      supplied at invocation, the shell becomes restricted.     A
      restricted shell is used to set up an    environment more
      controlled than the standard shell.  It behaves identically
      to bbbbaaaasssshhhh with the exception that the following    are disallowed
      or not performed:

      +o    changing    directories with ccccdddd

      +o    setting or unsetting the    values of SSSSHHHHEEEELLLLLLLL, PPPPAAAATTTTHHHH, EEEENNNNVVVV, or
           BBBBAAAASSSSHHHH____EEEENNNNVVVV

      +o    specifying command names    containing ////

      +o    specifying a file name containing a //// as    an argument to
           the .... builtin command

      +o    importing function definitions from the shell
           environment at startup




     Page 83                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      +o    parsing the value of SSSSHHHHEEEELLLLLLLLOOOOPPPPTTTTSSSS from the shell
           environment at startup

      +o    redirecting output using    the >, >|, <>, >&, &>, and >>
           redirection operators

      +o    using the eeeexxxxeeeecccc builtin command to replace the shell
           with another command

      +o    adding or deleting builtin commands with    the ----ffff and ----dddd
           options to the eeeennnnaaaabbbblllleeee builtin command

      +o    specifying the ----pppp option    to the ccccoooommmmmmmmaaaannnndddd builtin command

      +o    turning off restricted mode with    sssseeeetttt ++++rrrr or sssseeeetttt ++++oooo
           rrrreeeessssttttrrrriiiicccctttteeeedddd.

      These    restrictions are enforced after    any startup files are
      read.

      When a command that is found to be a shell script is
      executed (see    CCCCOOOOMMMMMMMMAAAANNNNDDDD    EEEEXXXXEEEECCCCUUUUTTTTIIIIOOOONNNN above), rrrrbbbbaaaasssshhhh    turns off any
      restrictions in the shell spawned to execute the script.

     SSSSEEEEEEEE AAAALLLLSSSSOOOO
      _B_a_s_h _F_e_a_t_u_r_e_s, Brian Fox and Chet Ramey
      _T_h_e _G_n_u _R_e_a_d_l_i_n_e _L_i_b_r_a_r_y, Brian Fox and Chet Ramey
      _T_h_e _G_n_u _H_i_s_t_o_r_y _L_i_b_r_a_r_y, Brian Fox and Chet Ramey
     _U_t_i_l_i_t_i_e_s,    IEEE
      _P_o_r_t_a_b_l_e _O_p_e_r_a_t_i_n_g _S_y_s_t_e_m _I_n_t_e_r_f_a_c_e (_P_O_S_I_X) _P_a_r_t _2: _S_h_e_l_l _a_n_d
      _s_h(1), _k_s_h(1), _c_s_h(1)
      _e_m_a_c_s(1), _v_i(1)
      _r_e_a_d_l_i_n_e(3)

     FFFFIIIILLLLEEEESSSS
      /_b_i_n/_b_a_s_h
           The bbbbaaaasssshhhh    executable
      /_e_t_c/_p_r_o_f_i_l_e
           The systemwide initialization file, executed for    login
           shells
      ~/._b_a_s_h__p_r_o_f_i_l_e
           The personal initialization file, executed for login
           shells
      ~/._b_a_s_h_r_c
           The individual per-interactive-shell startup file
      ~/._b_a_s_h__l_o_g_o_u_t
           The individual login shell cleanup file,    executed when
           a login shell exits
      ~/._i_n_p_u_t_r_c
           Individual _r_e_a_d_l_i_n_e initialization file

     AAAAUUUUTTTTHHHHOOOORRRRSSSS



     PPPPaaaaggggeeee 88884444                         ((((pppprrrriiiinnnntttteeeedddd 3333////22225555////99999999))))






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      Brian    Fox, Free Software Foundation
      [e-mail]

      Chet Ramey, Case Western Reserve University
      [e-mail]

     BBBBUUUUGGGG RRRREEEEPPPPOOOORRRRTTTTSSSS
      If you find a    bug in bbbbaaaasssshhhh,,,, you should    report it.  But    first,
      you should make sure that it really is a bug,    and that it
      appears in the latest    version    of bbbbaaaasssshhhh    that you have.

      Once you have    determined that    a bug actually exists, use the
      _b_a_s_h_b_u_g command to submit a bug report.  If you have a fix,
      you are encouraged to    mail that as well!  Suggestions    and
      `philosophical' bug reports may be mailed to _b_u_g-
      _b_a_s_h@_g_n_u._o_r_g or posted to the    Usenet newsgroup ggggnnnnuuuu....bbbbaaaasssshhhh....bbbbuuuugggg.

      ALL bug reports should include:

      The version number of    bbbbaaaasssshhhh
      The hardware and operating system
      The compiler used to compile
      A description    of the bug behaviour
      A short script or `recipe' which exercises the bug

      _b_a_s_h_b_u_g inserts the first three items    automatically into the
      template it provides for filing a bug    report.

      Comments and bug reports concerning this manual page should
      be directed to _c_h_e_t@_i_n_s._C_W_R_U._E_d_u.

     BBBBUUUUGGGGSSSS
      It's too big and too slow.

      There    are some subtle    differences between bbbbaaaasssshhhh and
      traditional versions of sssshhhh, mostly because of    the PPPPOOOOSSSSIIIIXXXX
      specification.

      Aliases are confusing    in some    uses.

      Shell    builtin    commands and functions are not
      stoppable/restartable.

      Compound commands and    command    sequences of the form `a ; b ;
      c' are not handled gracefully    when process suspension    is
      attempted.  When a process is    stopped, the shell immediately
      executes the next command in the sequence.  It suffices to
      place    the sequence of    commands between parentheses to    force
      it into a subshell, which may    be stopped as a    unit.

      Commands inside of $$$$((((...)))) command substitution are not
      parsed until substitution is attempted.  This    will delay



     Page 85                         (printed 3/25/99)






     BBBBAAAASSSSHHHH((((1111))))             GGGGNNNNUUUU ((((1111999999999999 JJJJaaaannnn 22220000))))               BBBBAAAASSSSHHHH((((1111))))



      error    reporting until    some time after    the command is
      entered.

      Array    variables may not (yet)    be exported.



















































     Page 86                         (printed 3/25/99)